rebuild to get Python 3.11.2

* print chromeaues/chromeversions cleanup, add print chromeneedsattn

* Fix typo

* Define new ChromeOS fields

.github/ISSUE_TEMPLATE.txt

@@ -0,0 +1,14 @@
+The issue tracker is for reporting product deficiencies. "How do I?" questions should be posted to the discussion forum at https://groups.google.com/group/google-apps-manager. When in doubt, start at the discussion forum and return here only when instructed to do so.
+
+Please confirm the following:
+* I have upgraded to the latest GAM release from https://github.com/GAM-team/GAM/releases and I still have this issue.
+* I am typing the command as described in the GAM Wiki at https://github.com/GAM-team/GAM/wiki
+
+Full steps to reproduce the issue:
+1.
+2.
+3.
+
+Expected outcome (what are you trying to do?):
+
+Actual outcome (what errors or bad behavior do you see instead?):

.github/ISSUE_TEMPLATE/aa-question.md

@@ -0,0 +1,14 @@
+---
+name: Question about using GAM
+about: Help with using GAM or running it for the first time
+title: Please use the GAM discussion group
+labels: invalid
+assignees: ''
+
+---
+
+If you need help with GAM, please do not file an issue here, it will be closed and ignored.
+
+Please post your question to the GAM discussion group where other admins are ready and willing to help:
+
+https://groups.google.com/g/google-apps-manager

.github/ISSUE_TEMPLATE/za-bug-report.md

@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: jay0lee
+
+---
+
+The issue tracker is for reporting product deficiencies. "How do I?" questions should be posted to the discussion forum at https://groups.google.com/group/google-apps-manager. When in doubt, start at the discussion forum and return here only when instructed to do so.
+
+Please confirm the following:
+* I have upgraded to the latest GAM release from https://github.com/GAM-team/GAM/releases and I still have this issue.
+* I am typing the command as described in the GAM Wiki at https://github.com/jay0lee/gam/wiki
+
+Full steps to reproduce the issue:
+1.
+2.
+3.
+
+Expected outcome (what are you trying to do?):
+
+Actual outcome (what errors or bad behavior do you see instead?):

.github/ISSUE_TEMPLATE/zz-feature-request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for GAM
+title: ''
+labels: enhancement
+assignees: jay0lee
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/actions/decrypt.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+gpgfile="$1"
+echo "source file is ${gpgfile}"
+credsfile="$2"
+echo "target file is ${credsfile}"
+if [ -z ${PASSCODE+x} ]; then
+  echo "PASSCODE is unset";
+else
+  echo "PASSCODE is set";
+fi
+
+gpg --quiet --batch --yes --decrypt --passphrase="${PASSCODE}" \
+    --output "${credsfile}" "${gpgfile}"
+
+tar xvvf "${credsfile}" --directory "${gampath}"
+rm -rvf "${gpgfile}"
+rm -rvf "${credsfile}"

.github/actions/package_exclusions.txt

@@ -0,0 +1,7 @@
+oauth2.txt
+nobrowser.txt
+enabledasa.txt
+lastupdatecheck.txt
+*.json
+*.lck
+*.csv

.github/stale.yml

@@ -0,0 +1,61 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+# Number of days of inactivity before an Issue or Pull Request becomes stale
+daysUntilStale: 90
+
+# Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
+# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
+daysUntilClose: 7
+
+# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled)
+onlyLabels: []
+
+# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
+exemptLabels:
+  - pinned
+  - enhancement
+  - help wanted
+  - security
+
+# Set to true to ignore issues in a project (defaults to false)
+exemptProjects: false
+
+# Set to true to ignore issues in a milestone (defaults to false)
+exemptMilestones: false
+
+# Set to true to ignore issues with an assignee (defaults to false)
+exemptAssignees: false
+
+# Label to use when marking as stale
+staleLabel: wontfix
+
+# Comment to post when marking as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs.
+
+# Comment to post when removing the stale label.
+# unmarkComment: >
+#   Your comment here.
+
+# Comment to post when closing a stale Issue or Pull Request.
+# closeComment: >
+#   Your comment here.
+
+# Limit the number of actions per hour, from 1-30. Default is 30
+limitPerRun: 30
+
+# Limit to only `issues` or `pulls`
+# only: issues
+
+# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls':
+# pulls:
+#   daysUntilStale: 30
+#   markComment: >
+#     This pull request has been automatically marked as stale because it has not had
+#     recent activity. It will be closed if no further activity occurs. Thank you
+#     for your contributions.
+
+# issues:
+#   exemptLabels:
+#     - confirmed

.github/workflows/build.yml

@@ -0,0 +1,793 @@
+name: Build and test GAM
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '37 22 * * *'
+
+defaults:
+  run:
+    shell: bash
+    working-directory: src
+
+env:
+  OPENSSL_CONFIG_OPTS: no-fips
+  OPENSSL_INSTALL_PATH: ${{ github.workspace }}/bin/ssl
+  OPENSSL_SOURCE_PATH: ${{ github.workspace }}/src/openssl
+  PYTHON_INSTALL_PATH: ${{ github.workspace }}/bin/python
+  PYTHON_SOURCE_PATH: ${{ github.workspace }}/src/cpython
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-20.04
+            jid: 1
+            goal: build
+            arch: x86_64
+            openssl_archs: linux-x86_64
+          - os: [self-hosted, linux, arm64, gcp]
+            jid: 2
+            goal: build
+            arch: aarch64
+            openssl_archs: linux-aarch64
+          - os: ubuntu-20.04
+            jid: 3
+            goal: build
+            arch: x86_64
+            openssl_archs: linux-x86_64
+            staticx: yes
+          - os: [self-hosted, linux, arm64, gcp]
+            jid: 4
+            goal: build
+            arch: aarch64
+            openssl_archs: linux-aarch64
+            staticx: yes
+          - os: macos-12
+            jid: 5
+            goal: build
+            arch: universal2
+            openssl_archs: darwin64-x86_64 darwin64-arm64
+          - os: windows-2022
+            jid: 6
+            goal: build
+            arch: Win64
+            openssl_archs: VC-WIN64A
+          - os: windows-2022
+            jid: 7
+            goal: build
+            arch: Win32
+            openssl_archs: VC-WIN32
+          - os: ubuntu-22.04
+            goal: test
+            python: "3.7"
+            jid: 8
+            arch: x86_64
+          - os: ubuntu-22.04
+            goal: test
+            python: "3.8"
+            jid: 9
+            arch: x86_64
+          - os: ubuntu-22.04
+            goal: test
+            python: "3.9"
+            jid: 10
+            arch: x86_64
+          - os: ubuntu-22.04
+            goal: test
+            python: "3.10"
+            jid: 11
+            arch: x86_64
+          - os: ubuntu-22.04
+            goal: test
+            python: "3.12.0-alpha - 3.12"
+            jid: 12
+            arch: x86_64
+
+    steps:
+
+      - uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+          fetch-depth: 0
+
+      - name: Cache multiple paths
+        if: matrix.goal == 'build'
+        uses: actions/cache@v3
+        id: cache-python-ssl
+        with:
+          path: |
+            bin.tar.xz
+            src/cpython
+          key: gam-${{ matrix.jid }}-20230208
+
+      - name: Untar Cache archive
+        if: matrix.goal == 'build' && steps.cache-python-ssl.outputs.cache-hit == 'true'
+        working-directory: ${{ github.workspace }}
+        run: |
+          tar xvvf bin.tar.xz
+
+      - name: Use pre-compiled Python for testing
+        if: matrix.python != ''
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python }}
+
+      - name: Set env variables for test
+        if: matrix.goal == 'test'
+        env:
+          JID: ${{ matrix.jid }}
+          ACTIONS_CACHE: ${{ steps.cache-python-ssl.outputs.cache-hit }}
+          ACTIONS_GOAL: ${{ matrix.goal }}
+        run: |
+             export PYTHON=$(which python3)
+             export PIP=$(which pip3)
+             export gam="${PYTHON} -m gam"
+             export gampath="$(readlink -e .)"
+             echo -e "PYTHON: ${PYTHON}\nPIP: ${PIP}\gam: ${gam}\ngampath: ${gampath}"
+             echo "PYTHON=${PYTHON}" >> $GITHUB_ENV
+             echo "PIP=${PIP}" >> $GITHUB_ENV
+             echo "gam=${gam}" >> $GITHUB_ENV
+             echo "gampath=${gampath}" >> $GITHUB_ENV
+             echo "JID=${JID}" >> $GITHUB_ENV
+             echo "ACTIONS_CACHE=${ACTIONS_CACHE}" >> $GITHUB_ENV
+             echo "ACTIONS_GOAL=${ACTIONS_GOAL}" >> $GITHUB_ENV
+
+      - name: Install necessary Github-hosted Linux packages
+        if: runner.os == 'Linux' && runner.arch == 'X64'
+        run: |
+          echo "RUNNING: apt update..."
+          sudo apt-get -qq --yes update
+          sudo apt-get -qq --yes install swig libpcsclite-dev
+
+     #- name: MacOS remove Homebrew
+     #  if: runner.os == 'macOS'
+     #  run: |
+     #    # remove everything except the libraries needed by yubikey-manager
+     #    brew uninstall $(brew list | grep -v 'pcre\|swig\|pcsc-lite')
+
+      - name: MacOS install tools
+        if: runner.os == 'macOS'
+        run: |
+          # Install latest Rust
+          curl --retry 5 --retry-connrefused -fsS -o rust.sh https://sh.rustup.rs
+          bash ./rust.sh -y
+          source $HOME/.cargo/env
+          # needed for Rust to compile cryptography Python package for universal2
+          rustup target add aarch64-apple-darwin
+
+      - name: Windows Configure VCode
+        uses: ilammy/msvc-dev-cmd@v1
+        if: runner.os == 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        with:
+          arch: ${{ matrix.arch }}
+
+      - name: Set Env Variables for build
+        if: matrix.goal == 'build'
+        env:
+          arch: ${{ matrix.arch }}
+          jid: ${{ matrix.jid }}
+          openssl_archs: ${{ matrix.openssl_archs }}
+          staticx: ${{ matrix.staticx }}
+        run: |
+          echo "We are running on ${RUNNER_OS}"
+          LD_LIBRARY_PATH="${OPENSSL_INSTALL_PATH}/lib:${PYTHON_INSTALL_PATH}/lib"
+          if [[ "${arch}" == "Win64" ]]; then
+            PYEXTERNALS_PATH="amd64"
+            PYBUILDRELEASE_ARCH="x64"
+            GAM_ARCHIVE_ARCH="x86_64"
+            WIX_ARCH="x64"
+            CHOC_OPS=""
+          elif [[ "${arch}" == "Win32" ]]; then
+            PYEXTERNALS_PATH="win32"
+            PYBUILDRELEASE_ARCH="Win32"
+            GAM_ARCHIVE_ARCH="x86"
+            WIX_ARCH="x86"
+            CHOC_OPS="--forcex86"
+          fi
+          if [[ "${RUNNER_OS}" == "macOS" ]]; then
+            #brew install coreutils
+            #brew install bash
+            MAKE=make
+            MAKEOPT="-j$(sysctl -n hw.logicalcpu)"
+            PERL=perl
+            echo "MACOSX_DEPLOYMENT_TARGET=10.15" >> $GITHUB_ENV
+            echo "PYTHON=${PYTHON_INSTALL_PATH}/bin/python3" >> $GITHUB_ENV
+            echo "PIP_ARGS=--no-binary=:all:" >> $GITHUB_ENV
+          elif [[ "${RUNNER_OS}" == "Linux" ]]; then
+            MAKE=make
+            MAKEOPT="-j$(nproc)"
+            PERL=perl
+            echo "PYTHON=${PYTHON_INSTALL_PATH}/bin/python3" >> $GITHUB_ENV
+          elif [[ "${RUNNER_OS}" == "Windows" ]]; then
+            MAKE=nmake
+            MAKEOPT=""
+            PERL="c:\strawberry\perl\bin\perl.exe"
+            LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:${PYTHON_SOURCE_PATH}/PCbuild/${PYEXTERNALS_PATH}"
+            echo "PYTHON=${PYTHON_SOURCE_PATH}/PCbuild/${PYEXTERNALS_PATH}/python.exe" >> $GITHUB_ENV
+            echo "GAM_ARCHIVE_ARCH=${GAM_ARCHIVE_ARCH}" >> $GITHUB_ENV
+            echo "WIX_ARCH=${WIX_ARCH}" >> $GITHUB_ENV
+          fi
+          echo "We'll run make with: ${MAKEOPT}"
+          echo "JID=${jid}" >> $GITHUB_ENV
+          echo "staticx=${staticx}" >> $GITHUB_ENV
+          echo "arch=${arch}" >> $GITHUB_ENV
+          echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH}" >> $GITHUB_ENV
+          echo "MAKE=${MAKE}" >> $GITHUB_ENV
+          echo "MAKEOPT=${MAKEOPT}" >> $GITHUB_ENV
+          echo "PERL=${PERL}" >> $GITHUB_ENV
+          echo "PYEXTERNALS_PATH=${PYEXTERNALS_PATH}" >> $GITHUB_ENV
+          echo "PYBUILDRELEASE_ARCH=${PYBUILDRELEASE_ARCH}" >> $GITHUB_ENV
+          echo "openssl_archs=${openssl_archs}" >> $GITHUB_ENV
+
+      - name: Get latest stable OpenSSL source
+        if: matrix.goal == 'build' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        run: |
+          mkdir -vp "${GITHUB_WORKSPACE}/src"
+          cd "${GITHUB_WORKSPACE}/src"
+          git clone https://github.com/openssl/openssl.git
+          cd "${OPENSSL_SOURCE_PATH}"
+          export LATEST_STABLE_TAG=$(git tag --list openssl-* | grep -v alpha | grep -v beta | sort -Vr | head -n1)
+          echo "Checking out version ${LATEST_STABLE_TAG}"
+          git checkout "${LATEST_STABLE_TAG}"
+          export COMPILED_OPENSSL_VERSION=${LATEST_STABLE_TAG:8} # Trim the openssl- prefix
+          echo "COMPILED_OPENSSL_VERSION=${COMPILED_OPENSSL_VERSION}" >> $GITHUB_ENV
+          if [[ "${RUNNER_OS}" == "macOS" ]]; then
+            for openssl_arch in $openssl_archs; do
+              ssldir="${OPENSSL_SOURCE_PATH}-${openssl_arch}"
+              mkdir -v "${ssldir}"
+              cp -vrf ${OPENSSL_SOURCE_PATH}/* "${ssldir}/"
+            done
+            rm -vrf "${OPENSSL_SOURCE_PATH}"
+          else
+            mv -v "${OPENSSL_SOURCE_PATH}" "${OPENSSL_SOURCE_PATH}-${openssl_archs}"
+          fi
+
+      - name: Windows NASM Install
+        uses: ilammy/setup-nasm@v1
+        if: matrix.goal == 'build' && runner.os == 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+
+      - name: Config OpenSSL
+        if: matrix.goal == 'build' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        run: |
+          for openssl_arch in $openssl_archs; do
+            cd "${GITHUB_WORKSPACE}/src/openssl-${openssl_arch}"
+            # --libdir=lib is needed so Python can find OpenSSL libraries
+            "${PERL}" ./Configure "${openssl_arch}" --libdir=lib --prefix="${OPENSSL_INSTALL_PATH}" $OPENSSL_CONFIG_OPTS
+          done
+
+      - name: Rename GNU link on Windows
+        if: matrix.goal == 'build' && runner.os == 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        shell: bash
+        run: mv /usr/bin/link /usr/bin/gnulink
+
+      - name: Make OpenSSL
+        if: matrix.goal == 'build' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        run: |
+          for openssl_arch in $openssl_archs; do
+            cd "${GITHUB_WORKSPACE}/src/openssl-${openssl_arch}"
+            $MAKE "${MAKEOPT}"
+          done
+
+      - name: Install OpenSSL
+        if: matrix.goal == 'build' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        run: |
+          if [[ "${RUNNER_OS}" == "macOS" ]]; then
+            for openssl_arch in $openssl_archs; do
+              cd "${GITHUB_WORKSPACE}/src/openssl-${openssl_arch}"
+              # install_sw saves us ages processing man pages :-)
+              $MAKE install_sw
+              mv "${OPENSSL_INSTALL_PATH}" "${GITHUB_WORKSPACE}/bin/ssl-${openssl_arch}"
+            done
+            mkdir -vp "${OPENSSL_INSTALL_PATH}/lib"
+            mkdir -vp "${OPENSSL_INSTALL_PATH}/bin"
+            for archlib in libcrypto.3.dylib libssl.3.dylib libcrypto.a libssl.a; do
+              lipo -create "${GITHUB_WORKSPACE}/bin/ssl-darwin64-x86_64/lib/${archlib}" \
+                           "${GITHUB_WORKSPACE}/bin/ssl-darwin64-arm64/lib/${archlib}" \
+                   -output "${GITHUB_WORKSPACE}/bin/ssl/lib/${archlib}"
+            done
+            mv ${GITHUB_WORKSPACE}/bin/ssl-darwin64-x86_64/include ${GITHUB_WORKSPACE}/bin/ssl/
+            lipo -create "${GITHUB_WORKSPACE}/bin/ssl-darwin64-x86_64/bin/openssl" \
+                         "${GITHUB_WORKSPACE}/bin/ssl-darwin64-arm64/bin/openssl" \
+                 -output "${GITHUB_WORKSPACE}/bin/ssl/bin/openssl"
+            rm -rf ${GITHUB_WORKSPACE}/bin/ssl-darwin64-x86_64
+            rm -rf ${GITHUB_WORKSPACE}/bin/ssl-darwin64-arm64
+            echo "LDFLAGS=-L${OPENSSL_INSTALL_PATH}/lib" >> $GITHUB_ENV
+            echo "CRYPTOGRAPHY_SUPPRESS_LINK_FLAGS=1" >> $GITHUB_ENV
+            echo "CFLAGS=-I${OPENSSL_INSTALL_PATH}/include -arch arm64 -arch x86_64" >> $GITHUB_ENV
+            echo "ARCHFLAGS=-arch x86_64 -arch arm64" >> $GITHUB_ENV
+          else
+            cd "${GITHUB_WORKSPACE}/src/openssl-${openssl_archs}"
+            # install_sw saves us ages processing man pages :-)
+            $MAKE install_sw
+          fi
+
+      - name: Run OpenSSL
+        if: matrix.goal == 'build'
+        run: |
+          "${OPENSSL_INSTALL_PATH}/bin/openssl" version
+          file "${OPENSSL_INSTALL_PATH}/bin/openssl"
+
+      - name: Get latest stable Python source
+        if: matrix.goal == 'build' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        run: |
+          cd "${GITHUB_WORKSPACE}/src"
+          git clone https://github.com/python/cpython.git
+          cd "${PYTHON_SOURCE_PATH}"
+          export LATEST_STABLE_TAG=$(git tag --list | grep -v a | grep -v rc | grep -v b | sort -Vr | head -n1)
+          git checkout "${LATEST_STABLE_TAG}"
+          export COMPILED_PYTHON_VERSION=${LATEST_STABLE_TAG:1} # Trim the "v" prefix
+          echo "COMPILED_PYTHON_VERSION=${COMPILED_PYTHON_VERSION}" >> $GITHUB_ENV
+
+      - name: Mac/Linux Configure Python
+        if: matrix.goal == 'build' && runner.os != 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        run: |
+          cd "${PYTHON_SOURCE_PATH}"
+          if [[ "${RUNNER_OS}" == "macOS" ]]; then
+            extra_args=( "--enable-universalsdk" "--with-universal-archs=universal2" )
+          else
+            extra_args=( )
+          fi
+          ./configure --with-openssl="${OPENSSL_INSTALL_PATH}" \
+                      --prefix="${PYTHON_INSTALL_PATH}" \
+                      --enable-shared \
+                      --with-ensurepip=upgrade \
+                      --enable-optimizations \
+                      --with-lto \
+                      "${extra_args[@]}"
+
+      - name: Windows Get External Python deps
+        if: matrix.goal == 'build' && runner.os == 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          cd "${env:PYTHON_SOURCE_PATH}"
+          PCBuild\get_externals.bat
+
+      - name: Windows overwrite external OpenSSL with local
+        if: matrix.goal == 'build' && runner.os == 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          cd "${env:PYTHON_SOURCE_PATH}"
+          $env:OPENSSL_EXT_PATH = "$(Get-Item externals\openssl-bin-* | Select -exp FullName)\"
+          echo "External OpenSSL was downloaded to ${env:OPENSSL_EXT_PATH}"
+          Remove-Item -recurse -force "${env:OPENSSL_EXT_PATH}*"
+          # Emulate what this script does:
+          # https://github.com/python/cpython/blob/main/PCbuild/openssl.vcxproj
+          $env:OPENSSL_EXT_TARGET_PATH = "${env:OPENSSL_EXT_PATH}${env:PYEXTERNALS_PATH}"
+          echo "Copying our OpenSSL to ${env:OPENSSL_EXT_TARGET_PATH}"
+          mkdir "${env:OPENSSL_EXT_TARGET_PATH}\include\openssl\"
+          Copy-Item -Path "${env:GITHUB_WORKSPACE}/src/openssl-${env:openssl_archs}\LICENSE.txt" -Destination "${env:OPENSSL_EXT_TARGET_PATH}\LICENSE" -Verbose
+          cp -v "$env:OPENSSL_INSTALL_PATH\lib\*" "${env:OPENSSL_EXT_TARGET_PATH}"
+          cp -v "$env:OPENSSL_INSTALL_PATH\bin\*" "${env:OPENSSL_EXT_TARGET_PATH}"
+          cp -v "$env:OPENSSL_INSTALL_PATH\include\openssl\*" "${env:OPENSSL_EXT_TARGET_PATH}\include\openssl\"
+          cp -v "$env:OPENSSL_INSTALL_PATH\include\openssl\applink.c" "${env:OPENSSL_EXT_TARGET_PATH}\include\"
+
+      - name: Windows Install sphinx-build
+        if: matrix.goal == 'build' && runner.os == 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          pip install --upgrade pip
+          pip install --upgrade sphinx
+          sphinx-build --version
+
+      - name: Windows Config/Build Python
+        if: matrix.goal == 'build' && runner.os == 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        shell: powershell
+        run: |
+          cd "${env:PYTHON_SOURCE_PATH}"
+          # We need out custom openssl.props which uses OpenSSL 3 DLL names
+          Copy-Item -Path "${env:GITHUB_WORKSPACE}\src\tools\openssl.props" -Destination PCBuild\ -Verbose
+          echo "Building for ${env:PYBUILDRELEASE_ARCH}..."
+          PCBuild\build.bat -m --pgo -c Release -p "${env:PYBUILDRELEASE_ARCH}"
+
+      - name: Mac/Linux Build Python
+        if: matrix.goal == 'build' && runner.os != 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        run: |
+          cd "${PYTHON_SOURCE_PATH}"
+          echo "Running: ${MAKE} ${MAKEOPT}"
+          $MAKE $MAKEOPT
+
+      - name: Mac/Linux Install Python
+        if: matrix.goal == 'build' && runner.os != 'Windows' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        run: |
+          cd "${PYTHON_SOURCE_PATH}"
+          $MAKE altinstall
+          $MAKE bininstall
+          export PATH="${PATH}:${PYTHON_INSTALL_PATH}/bin"
+          echo "PATH=${PATH}" >> $GITHUB_ENV
+          echo "PATH: ${PATH}"
+
+      - name: Run Python
+        run: |
+          "${PYTHON}" -V
+
+      - name: Upgrade pip, wheel, etc
+        run: |
+          curl --retry 5 --retry-connrefused -O https://bootstrap.pypa.io/get-pip.py
+          "${PYTHON}" get-pip.py
+          "${PYTHON}" -m pip install --upgrade pip
+          "${PYTHON}" -m pip install --upgrade wheel
+          "${PYTHON}" -m pip install --upgrade setuptools
+
+      - name: Install pip requirements
+        run: |
+             if [[ "${RUNNER_OS}" == "macOS" ]]; then
+               "${PYTHON}" -m pip install --upgrade cffi ${PIP_ARGS}
+               "${PYTHON}" -m pip download --only-binary :all: \
+                                             --dest . \
+                                             --no-cache \
+                                             --no-deps \
+                                             --platform macosx_10_15_universal2 \
+                                             cryptography
+               "${PYTHON}" -m pip install --force-reinstall --no-deps cryptography*.whl
+             fi
+             "${PYTHON}" -m pip install --upgrade -r requirements.txt ${PIP_ARGS}
+             "${PYTHON}" -m pip list
+
+      - name: Install PyInstaller
+        if: matrix.goal == 'build'
+        run: |
+          git clone https://github.com/pyinstaller/pyinstaller.git
+          cd pyinstaller
+          export latest_release=$(git tag --list | grep -v dev | grep -v rc | sort -Vr | head -n1)
+          git checkout "${latest_release}"
+          # remove pre-compiled bootloaders so we fail if bootloader compile fails
+          rm -rvf PyInstaller/bootloader/*-*/*
+          cd bootloader
+          case "${arch}" in
+            "Win32")
+              export PYINSTALLER_BUILD_ARGS="--target-arch=32bit"
+              ;;
+            "Win64")
+              export PYINSTALLER_BUILD_ARGS="--target-arch=64bit"
+              ;;
+          esac
+          echo "PyInstaller build arguments: ${PYINSTALLER_BUILD_ARGS}"
+          "${PYTHON}" ./waf all $PYINSTALLER_BUILD_ARGS
+          cd ..
+          echo "---- Installing PyInstaller ----"
+          "${PYTHON}" -m pip install .
+
+      - name: Build GAM with PyInstaller
+        if: matrix.goal != 'test'
+        run: |
+             if [[ "${staticx}" == "yes" ]]; then
+               export distpath="./dist/gam"
+               export gampath="${distpath}"
+             else
+               export distpath="./dist"
+               export gampath="${distpath}/gam"
+             fi
+             mkdir -p -v "${gampath}"
+             if [[ "${RUNNER_OS}" == "macOS" ]]; then
+               export gampath=$($PYTHON -c "import os; print(os.path.realpath('$gampath'))")
+             elif [[ "${RUNNER_OS}" == "Windows" ]]; then
+               # Work around issue where PyInstaller picks up python3.dll from other Python versions
+               # https://github.com/pyinstaller/pyinstaller/issues/7102
+               export PATH="/usr/bin"
+             else
+               export gampath=$(realpath "${gampath}")
+             fi
+             export gam="${gampath}/gam"
+             echo "gampath=${gampath}" >> $GITHUB_ENV
+             echo "gam=${gam}" >> $GITHUB_ENV
+             echo -e "GAM: ${gam}\nGAMPATH: ${gampath}"
+             # TEMP force everything back to one file.
+             export PYINSTALLER_BUILD_ONEFILE="yes"
+             export distpath="./dist/gam"
+             export gampath="${distpath}"
+             "${PYTHON}" -m PyInstaller --clean --noconfirm --distpath="${distpath}" gam.spec
+ 
+      - name: Copy extra package files
+        if: matrix.goal == 'build'
+        run: |
+          cp -v roots.pem $gampath
+          cp -v LICENSE $gampath
+          cp -v GamCommands.txt $gampath
+          if [[ "${RUNNER_OS}" == "Windows" ]]; then
+              cp -v gam-setup.bat $gampath
+          fi
+
+      - name: Basic Tests all jobs
+        run: |
+             $PYTHON -m unittest discover --start-directory ./ --pattern "*_test.py" --buffer
+             $gam version extended
+             export GAMVERSION=$($gam version simple)
+             echo "GAM Version ${GAMVERSION}"
+             echo "GAMVERSION=${GAMVERSION}" >> $GITHUB_ENV
+
+      - name: Linux/MacOS package
+        if: runner.os != 'Windows' && matrix.goal == 'build' && matrix.staticx != 'yes'
+        run: |
+          if [[ "${RUNNER_OS}" == "macOS" ]]; then
+              GAM_ARCHIVE="gam-${GAMVERSION}-macos-universal2.tar.xz"
+          elif [[ "${RUNNER_OS}" == "Linux" ]]; then
+              this_glibc_ver=$(ldd --version | awk '/ldd/{print $NF}')
+              GAM_ARCHIVE="gam-${GAMVERSION}-linux-$(arch)-glibc${this_glibc_ver}.tar.xz"
+          fi
+          tar -C dist/ --create --verbose --exclude-from "${GITHUB_WORKSPACE}/.github/actions/package_exclusions.txt" --file $GAM_ARCHIVE --xz gam
+
+      - name: Install StaticX
+        if: matrix.staticx == 'yes'
+        run: |
+          "${PYTHON}" -m pip install --upgrade patchelf-wrapper
+          "${PYTHON}" -m pip install --upgrade staticx
+
+      - name: Make StaticX
+        if: matrix.staticx == 'yes'
+        run: |
+          case $RUNNER_ARCH in
+            X64)
+              ldlib=/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
+              ;;
+            ARM64)
+              ldlib=/lib/aarch64-linux-gnu/ld-linux-aarch64.so.1
+              ;;
+          esac
+          echo "ldlib=${ldlib}"
+          $PYTHON -m staticx -l "${ldlib}" "${gam}" "${gam}-staticx"
+          
+      - name: Run StaticX
+        if: matrix.staticx == 'yes'
+        run: |
+          "${gam}-staticx" version extended
+          mv -v "${gam}-staticx" "${gam}"
+
+      - name: Linux package staticx
+        if: matrix.staticx == 'yes'
+        run: |
+          GAM_ARCHIVE="gam-${GAMVERSION}-linux-$(uname -m)-legacy.tar.xz"
+          tar -C dist/ --create --verbose --exclude-from "${GITHUB_WORKSPACE}/.github/actions/package_exclusions.txt" --file $GAM_ARCHIVE --xz gam
+
+      - name: Windows package
+        if: runner.os == 'Windows' && matrix.goal != 'test'
+        run: |
+          cd dist/
+          GAM_ARCHIVE="../gam-${GAMVERSION}-windows-${GAM_ARCHIVE_ARCH}.zip"
+          /c/Program\ Files/7-Zip/7z.exe a -tzip $GAM_ARCHIVE gam "-xr@${GITHUB_WORKSPACE}/.github/actions/package_exclusions.txt" -bb3
+          cd ..
+          /c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.11/bin/candle.exe -arch "${WIX_ARCH}" gam.wxs
+          /c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.11/bin/light.exe -ext /c/Program\ Files\ \(x86\)/WiX\ Toolset\ v3.11/bin/WixUIExtension.dll gam.wixobj -o "gam-${GAMVERSION}-windows-${GAM_ARCHIVE_ARCH}.msi" || true;
+          rm -v -f *.wixpdb
+
+      - name: Basic Tests build jobs only
+        if: matrix.goal != 'test' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        run: |
+          export voutput=$($gam version extended)
+          export python_line=$(echo -e "${voutput}" | grep "Python ")
+          export python_arr=($python_line)
+          export this_python=${python_arr[1]}
+          if [[ "${this_python}" != "${COMPILED_PYTHON_VERSION}" ]]; then
+            echo "ERROR: Tried to compile Python ${COMPILED_PYTHON_VERSION} but ended up with ${this_python}"
+            exit 1
+          fi
+          export openssl_line=$(echo -e "${voutput}" | grep "OpenSSL ")
+          export openssl_arr=($openssl_line)
+          export this_openssl="${openssl_arr[1]}"
+          if [[ "${this_openssl}" != "${COMPILED_OPENSSL_VERSION}" ]]; then
+            echo "ERROR: Tried to compile OpenSSL ${COMPILED_OPENSSL_VERSION} but ended up with ${this_openssl}"
+            exit 1
+          fi
+          echo "We successfully compiled Python ${this_python} and OpenSSL ${this_openssl}"
+
+      - name: Live API tests push only
+        if: github.event_name == 'push' || github.event_name == 'schedule'
+        env:
+          PASSCODE: ${{ secrets.PASSCODE }}
+        run: |
+             if [[ "${RUNNER_OS}" == "macOS" ]]; then
+               brew install gnupg
+             fi
+             source ../.github/actions/decrypt.sh ../.github/actions/creds.tar.xz.gpg creds.tar.xz
+             export OAUTHFILE="oauth2.txt-gam-gha-${JID}"
+             echo "OAUTHFILE=${OAUTHFILE}" >> $GITHUB_ENV
+             export gam_user="gam-gha-${JID}@pdl.jaylee.us"
+             echo "gam_user=${gam_user}" >> $GITHUB_ENV
+             $gam checkconn
+             $gam oauth info
+             $gam info domain
+             $gam oauth refresh
+             $gam info user
+             export tstamp=$($PYTHON -c "import time; print(time.time_ns())")
+             export newbase="gha_test_${JID}_${tstamp}"
+             export newuser="${newbase}@pdl.jaylee.us"
+             export newgroup="${newbase}-group@pdl.jaylee.us"
+             export newalias="${newbase}-alias@pdl.jaylee.us"
+             export newbuilding="${newbase}-building"
+             export newresource="${newbase}-resource"
+             export newou="aaaGithub Actions/${newbase}"
+             
+             # cleanup old runs
+             GAM_CSV_ROW_FILTER="name:regex:gha_test_${JID}_" $gam print vaultholds | $gam csv - gam delete vaulthold "id:~~holdId~~" matter "id:~~matterId~~"
+             GAM_CSV_ROW_FILTER="name:regex:gha_test_${JID}_" $gam print features | $gam csv - gam delete feature ~name
+             GAM_CSV_ROW_FILTER="name:regex:^gha_test_${JID}_" $gam user $gam_user print shareddrives asadmin | $gam csv - gam user $gam_user delete shareddrive ~id nukefromorbit
+             $gam print users query "gha.jid=$JID" | $gam csv - gam delete user ~primaryEmail
+             GAM_CSV_ROW_FILTER="name:regex:^gha_test_${JID}_" $gam print ous fromparent "aaaGithub Actions" | $gam csv - gam delete ou ~orgUnitId
+             GAM_CSV_ROW_FILTER="groupKey.id:regex:^gha_test_${JID}_" $gam print cigroups | $gam csv - gam delete cigroup ~groupKey.id
+             GAM_CSV_ROW_FILTER="resourceId:regex:^gha_test_${JID}_" $gam print resources | $gam csv - gam delete resource ~resourceId
+             GAM_CSV_ROW_FILTER="buildingId:regex:^gha_test_${JID}_" $gam print buildings | $gam csv - gam delete building ~buildingId
+             
+             echo "Creating OrgUnit ${newou}"
+             $gam create ou "${newou}"
+             export GAM_THREADS=5
+             echo email > sample.csv;
+             for i in {1..10}; do
+               echo "${newbase}-bulkuser-$i" >> sample.csv;
+             done
+             $gam create user $newuser firstname GHA lastname $JID displayname "Github Actions ${JID}" password random ou "${newou}" recoveryphone 12125121110 recoveryemail jay0lee@gmail.com gha.jid $JID languages en+,en-GB-
+             $gam user $newuser update photo https://dummyimage.com/400x600/000/fff
+             $gam user $newuser get photo
+             $gam user $newuser delete photo
+             $gam create group $newgroup name "GHA $JID group" description "This is a description" isarchived true
+             $gam user $gam_user sendemail recipient $newuser subject "test message $newbase" message "GHA test message"
+             $gam user $gam_user sendemail recipient exchange@pdl.jaylee.us subject "test ${tstamp}" message "test message"
+             $gam user $newuser add license workspaceenterpriseplus
+             $gam print privileges
+             $gam update cigroup $newgroup memberrestriction 'member.type == 1 || member.customer_id == groupCustomerId()'
+             $gam info cigroup $newgroup
+             $gam update group $newgroup add owner $gam_user
+             $gam update group $newgroup add member $newuser
+             $gam create admin $newuser _GROUPS_EDITOR_ROLE CUSTOMER # condition nonsecuritygroup
+             $gam csv sample.csv gam create user ~~email~~ firstname "GHA Bulk" lastname ~~email~~ gha.jid $JID ou "${newou}"
+             $gam csv sample.csv gam update user ~~email~~ recoveryphone 12125121110 recoveryemail jay0lee@gmail.com password random displayname "GitHub Actions Bulk ${JID}"
+             $gam csv sample.csv gam update user ~~email~~ recoveryphone "" recoveryemail ""
+             $gam csv sample.csv gam user ~email add license workspaceenterpriseplus
+             $gam csv sample.csv gam user $gam_user sendemail recipient ~~email~~@pdl.jaylee.us subject "test message $newbase" message "GHA test message"
+             $gam csv sample.csv gam update group $newgroup add member ~email
+             $gam info group $newgroup
+             $gam info cigroup $newgroup membertree
+             $gam user $gam_user check serviceaccount
+             # confirm mailbox is provisoned before continuing
+             $gam user $newuser waitformailbox
+             $gam user $newuser imap on
+             $gam user $newuser show imap
+             $gam user $newuser show delegates
+             #$gam user $newuser add contactdelegate "${newbase}-bulkuser-1"
+             #$gam user $newuser print contactdelegates
+             export biohazard=$(echo -e '\xe2\x98\xa3')
+             $gam user $newuser label "$biohazard unicode biohazard $biohazard"
+             $gam user $newuser show labels
+             $gam user $newuser show labels > labels.txt
+             $gam user $gam_user importemail subject "GHA import $newbase" message "This is a test import" labels IMPORTANT,UNREAD,INBOX,STARRED
+             $gam user $gam_user insertemail subject "GHA insert $newbase" file gam.py labels INBOX,UNREAD # yep body is gam code
+             $gam user $gam_user sendemail subject "GHA send $gam_user $newbase" file gam.py recipient admin@pdl.jaylee.us
+             $gam user $gam_user draftemail subject "GHA draft $newbase" message "Draft message test"
+             $gam csvfile sample.csv:email waitformailbox
+             $gam user $newuser delegate to "${newbase}-bulkuser-1"
+             $gam users "$gam_user $newbase-bulkuser-1 $newbase-bulkuser-2 $newbase-bulkuser-3" delete messages query in:anywhere maxtodelete 99999 doit
+             $gam users "$newbase-bulkuser-4 $newbase-bulkuser-5 $newbase-bulkuser-6" trash messages query in:anywhere maxtotrash 99999 doit
+             $gam users "$newbase-bulkuser-7 $newbase-bulkuser-8 $newbase-bulkuser-9" modify messages query in:anywhere maxtomodify 99999 addlabel IMPORTANT addlabel STARRED doit
+             $gam user $newuser delete label --ALL_LABELS--
+             GAM_CSV_ROW_FILTER="name:regex:gha-test-${JID}" $gam print features | $gam csv - gam delete feature ~name
+             $gam create feature name VC-$newbase
+             $gam create feature name Whiteboard-$newbase
+             $gam create building "My Building - $newbase" id $newbuilding floors 1,2,3,4,5,6,7,8,9,10,11,12,14,15 description "No 13th floor here..."
+             $gam create resource $newresource "Resource Calendar $tstamp" capacity 25 features Whiteboard-$newbase,VC-$newbase building $newbuilding floor 15 type Room
+             $gam info resource $newresource
+             $gam user $newuser show filelist
+             $gam calendar $gam_user printacl | $gam csv - gam calendar $gam_user delete id ~id # clear ACLs
+             $gam calendar $gam_user update read domain
+             $gam calendar $gam_user update freebusy default
+             $gam calendar $gam_user add editor $newuser
+             $gam calendar $gam_user showacl
+             $gam calendar $gam_user printacl | $gam csv - gam calendar $gam_user delete id ~id
+             starttime=$($PYTHON -c "import datetime; print((datetime.datetime.now() + datetime.timedelta(hours=1)).strftime('%Y-%m-%dT%H:%M:%S.%f+00:00'))")
+             endtime=$($PYTHON -c "import datetime; print((datetime.datetime.now() + datetime.timedelta(hours=2)).strftime('%Y-%m-%dT%H:%M:%S.%f+00:00'))")
+             $gam calendar $gam_user addevent summary "GHA test event" start "${starttime}" end "${endtime}" attendee $newgroup hangoutsmeet guestscanmodify true sendupdates all
+             $gam calendar $gam_user printevents after -0d
+             matterid=uid:$($gam create vaultmatter name "GHA matter $newbase" description "test matter" collaborators $newuser | head -1 | cut -d ' ' -f 3)
+             $gam create vaulthold matter $matterid name "GHA hold $newbase" corpus mail accounts $newuser
+             $gam print vaultmatters matterstate open
+             $gam print vaultholds matter $matterid
+             $gam print vaultcount matter $matterid corpus mail everyone todrive
+             $gam create vaultexport matter $matterid name "GHA export $newbase" corpus mail accounts $newuser use_new_export false
+             $gam print exports matter $matterid | $gam csv - gam info export $matterid id:~~id~~
+             $gam csv sample.csv gam user ~email add calendar id:$newresource
+             $gam delete resource $newresource
+             $gam delete feature Whiteboard-$newbase
+             $gam delete feature VC-$newbase
+             $gam delete building $newbuilding
+             $gam delete group $newgroup
+             $gam create alias $newalias user $newuser
+             $gam user $newuser delete license workspaceenterpriseplus
+             $gam whatis $newuser
+             $gam user $gam_user show tokens
+             $gam print exports matter $matterid | $gam csv - gam download export $matterid id:~~id~~
+             $gam delete hold "GHA hold $newbase" matter $matterid
+             $gam update matter $matterid action close
+             $gam update matter $matterid action delete
+             # shakes off vault hold on user so we can delete
+             $gam print users query "email:${newuser}" orgunitpath | $gam csv - gam update user ~primaryEmail ou ~orgUnitPath
+             $gam user $newuser show holds
+             $gam delete user $newuser
+             $gam print users query "gha.jid=$JID" | $gam csv - gam delete user ~primaryEmail
+             $gam print mobile
+             $gam print devices
+             $gam print browsers
+             export sn="$JID$JID$JID$JID-$(openssl rand -base64 32 | sed 's/[^a-zA-Z0-9]//g')"
+             $gam create device serialnumber $sn devicetype android
+             $gam print cros allfields orderby serialnumber
+             $gam show crostelemetry storagepercentonly
+             $gam report usageparameters customer
+             $gam report usage customer parameters gmail:num_emails_sent,accounts:num_1day_logins
+             $gam report customer todrive
+             $gam report users fields accounts:is_less_secure_apps_access_allowed,gmail:last_imap_time,gmail:last_pop_time filters "accounts:last_login_time>2019-01-01T00:00:00.000Z" todrive
+             $gam report admin start -3d todrive
+             $gam print devices nopersonaldevices nodeviceusers filter "serial:$JID$JID$JID$JID-" | $gam csv - gam delete device id ~name
+             $gam print userinvitations
+             $gam print userinvitations | $gam csv - gam send userinvitation ~name
+             $gam create caalevel "zzz_${newbase}" basic condition ipsubnetworks 1.1.1.1/32,2.2.2.2/32 endcondition
+             $gam print caalevels
+             $gam delete caalevel "zzz_${newbase}"
+             driveid=$($gam user $gam_user add shareddrive "${newbase}" | awk '{print $NF}')
+             echo "Created shared drive ${driveid}"
+             $gam user $gam_user add drivefile localfile gam.py parentid "${driveid}"
+             $gam user $gam_user update shareddrive "${driveid}" ou "${newou}"
+             $gam user $gam_user show shareddrives asadmin
+             $gam user $gam_user update shareddrive "${driveid}" ou "aaaGithub Actions" # so we can delete our OU...
+             $gam user $gam_user delete shareddrive "${driveid}" nukefromorbit
+             echo "printer model count:"
+             $gam print printermodels | wc -l
+             #ssoprofile=$($gam create inboundssoprofile name "El Goog ${newbase}" loginurl https://www.google.com logouturl https://www.google.com changepasswordurl https://www.google.com entityid ElGoog return_name_only)
+             #$gam create inboundssocredential profile "id:${ssoprofile}" generate_key
+             #$gam create inboundssoassignment profile "id:${ssoprofile}" orgunit "${newou}" mode SAML_SSO
+             $gam delete ou "${newou}"
+             #$gam delete inboundssoprofile "id:${ssoprofile}"
+             #$gam print printers
+             #$gam create printer displayname "${newbase}" uri ipp://localhost:631 driverless description "made by $(gam_user)" ou /
+             export CUSTOMER_ID="C01wfv983"
+             export GA_DOMAIN="pdl.jaylee.us"
+             touch $gampath/enabledasa.txt
+             echo "using delegated admin service account"
+             $gam print users
+
+      - name: Archive production artifacts
+        uses: actions/upload-artifact@v3
+        if: (github.event_name == 'push' || github.event_name == 'schedule') && matrix.goal != 'test'
+        with:
+          name: gam-binaries
+          path: |
+            src/*.tar.xz
+            src/*.zip
+            src/*.msi
+
+      - name: Tar Cache archive
+        if: matrix.goal == 'build' && steps.cache-python-ssl.outputs.cache-hit != 'true'
+        working-directory: ${{ github.workspace }}
+        run: |
+          tar cJvvf bin.tar.xz bin/
+
+  publish:
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+
+      - uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+          fetch-depth: 0
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
+
+      - name: VirusTotal Scan
+        uses: crazy-max/ghaction-virustotal@v3
+        with:
+          vt_api_key: ${{ secrets.VT_API_KEY }}
+          files: |
+            gam-binaries/*
+
+      - uses: "marvinpinto/action-automatic-releases@latest"
+        name: Publish draft release
+        with:
+          repo_token: "${{ secrets.GITHUB_TOKEN }}"
+          automatic_release_tag: latest
+          prerelease: false
+          draft: true
+          files: |
+            gam-binaries/*

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,70 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '25 10 * * 1'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/get-roots.yml

@@ -0,0 +1,36 @@
+name: Check for Google Root CA Updates
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '23 23 * * *'
+
+defaults:
+  run:
+    shell: bash
+    working-directory: src
+
+jobs:
+  check-apis:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+        with:
+          persist-credentials: false # otherwise, the token used is the GITHUB_TOKEN, instead of your personal token
+          fetch-depth: 0 # otherwise, you will failed to push refs to dest repo
+
+      - name: Check for updates
+        run: curl -o ./roots.pem -vvvv https://pki.goog/roots.pem
+
+      - name: Commit file
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git add roots.pem
+          git diff --quiet && git diff --staged --quiet || git commit -am '[ci skip] Updated roots.pem'
+
+      - name: Push changes
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }} 

.pre-commit-config.yaml

@@ -0,0 +1,32 @@
+# See https://pre-commit.com for more information
+
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.5.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: double-quote-string-fixer
+    -   id: check-yaml
+    -   id: check-docstring-first
+    -   id: name-tests-test
+    -   id: requirements-txt-fixer
+    -   id: check-merge-conflict
+
+-   repo: https://github.com/pre-commit/mirrors-yapf
+    rev: v0.30.0
+    hooks:
+    -   id: yapf
+        args: [--style=google, --in-place]
+
+-   repo: https://github.com/PyCQA/pylint
+    rev: pylint-2.5.0
+    hooks:
+    -   id: pylint
+        args: [--output-format=colorized]
+
+-   repo: https://github.com/asottile/pyupgrade
+    rev: v2.31.0
+    hooks:
+    -   id: pyupgrade
+        args: [--py37-plus]

LICENSE

@@ -199,349 +199,3 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-
-
-
-APACHE HTTP SERVER SUBCOMPONENTS: 
-
-The Apache HTTP Server includes a number of subcomponents with
-separate copyright notices and license terms. Your use of the source
-code for the these subcomponents is subject to the terms and
-conditions of the following licenses. 
-
-For the mod_mime_magic component:
-
-/*
- * mod_mime_magic: MIME type lookup via file magic numbers
- * Copyright (c) 1996-1997 Cisco Systems, Inc.
- *
- * This software was submitted by Cisco Systems to the Apache Group in July
- * 1997.  Future revisions and derivatives of this source code must
- * acknowledge Cisco Systems as the original contributor of this module.
- * All other licensing and usage conditions are those of the Apache Group.
- *
- * Some of this code is derived from the free version of the file command
- * originally posted to comp.sources.unix.  Copyright info for that program
- * is included below as required.
- * ---------------------------------------------------------------------------
- * - Copyright (c) Ian F. Darwin, 1987. Written by Ian F. Darwin.
- *
- * This software is not subject to any license of the American Telephone and
- * Telegraph Company or of the Regents of the University of California.
- *
- * Permission is granted to anyone to use this software for any purpose on any
- * computer system, and to alter it and redistribute it freely, subject to
- * the following restrictions:
- *
- * 1. The author is not responsible for the consequences of use of this
- * software, no matter how awful, even if they arise from flaws in it.
- *
- * 2. The origin of this software must not be misrepresented, either by
- * explicit claim or by omission.  Since few users ever read sources, credits
- * must appear in the documentation.
- *
- * 3. Altered versions must be plainly marked as such, and must not be
- * misrepresented as being the original software.  Since few users ever read
- * sources, credits must appear in the documentation.
- *
- * 4. This notice may not be removed or altered.
- * -------------------------------------------------------------------------
- *
- */
-
-
-For the  modules\mappers\mod_imagemap.c component:
-
-  "macmartinized" polygon code copyright 1992 by Eric Haines, erich@eye.com
-
-For the  server\util_md5.c component:
-
-/************************************************************************
- * NCSA HTTPd Server
- * Software Development Group
- * National Center for Supercomputing Applications
- * University of Illinois at Urbana-Champaign
- * 605 E. Springfield, Champaign, IL 61820
- * httpd@ncsa.uiuc.edu
- *
- * Copyright  (C)  1995, Board of Trustees of the University of Illinois
- *
- ************************************************************************
- *
- * md5.c: NCSA HTTPd code which uses the md5c.c RSA Code
- *
- *  Original Code Copyright (C) 1994, Jeff Hostetler, Spyglass, Inc.
- *  Portions of Content-MD5 code Copyright (C) 1993, 1994 by Carnegie Mellon
- *     University (see Copyright below).
- *  Portions of Content-MD5 code Copyright (C) 1991 Bell Communications 
- *     Research, Inc. (Bellcore) (see Copyright below).
- *  Portions extracted from mpack, John G. Myers - jgm+@cmu.edu
- *  Content-MD5 Code contributed by Martin Hamilton (martin@net.lut.ac.uk)
- *
- */
-
-
-/* these portions extracted from mpack, John G. Myers - jgm+@cmu.edu */
-/* (C) Copyright 1993,1994 by Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify, distribute, and sell this software
- * and its documentation for any purpose is hereby granted without
- * fee, provided that the above copyright notice appear in all copies
- * and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of Carnegie
- * Mellon University not be used in advertising or publicity
- * pertaining to distribution of the software without specific,
- * written prior permission.  Carnegie Mellon University makes no
- * representations about the suitability of this software for any
- * purpose.  It is provided "as is" without express or implied
- * warranty.
- *
- * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
- * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
- * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
- * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
- * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
- * SOFTWARE.
- */
-
-/*
- * Copyright (c) 1991 Bell Communications Research, Inc. (Bellcore)
- *
- * Permission to use, copy, modify, and distribute this material
- * for any purpose and without fee is hereby granted, provided
- * that the above copyright notice and this permission notice
- * appear in all copies, and that the name of Bellcore not be
- * used in advertising or publicity pertaining to this
- * material without the specific, prior written permission
- * of an authorized representative of Bellcore.  BELLCORE
- * MAKES NO REPRESENTATIONS ABOUT THE ACCURACY OR SUITABILITY
- * OF THIS MATERIAL FOR ANY PURPOSE.  IT IS PROVIDED "AS IS",
- * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.  
- */
-
-For the  srclib\apr\include\apr_md5.h component: 
-/*
- * This is work is derived from material Copyright RSA Data Security, Inc.
- *
- * The RSA copyright statement and Licence for that original material is
- * included below. This is followed by the Apache copyright statement and
- * licence for the modifications made to that material.
- */
-
-/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
-   rights reserved.
-
-   License to copy and use this software is granted provided that it
-   is identified as the "RSA Data Security, Inc. MD5 Message-Digest
-   Algorithm" in all material mentioning or referencing this software
-   or this function.
-
-   License is also granted to make and use derivative works provided
-   that such works are identified as "derived from the RSA Data
-   Security, Inc. MD5 Message-Digest Algorithm" in all material
-   mentioning or referencing the derived work.
-
-   RSA Data Security, Inc. makes no representations concerning either
-   the merchantability of this software or the suitability of this
-   software for any particular purpose. It is provided "as is"
-   without express or implied warranty of any kind.
-
-   These notices must be retained in any copies of any part of this
-   documentation and/or software.
- */
-
-For the  srclib\apr\passwd\apr_md5.c component:
-
-/*
- * This is work is derived from material Copyright RSA Data Security, Inc.
- *
- * The RSA copyright statement and Licence for that original material is
- * included below. This is followed by the Apache copyright statement and
- * licence for the modifications made to that material.
- */
-
-/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
- */
-
-/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
-   rights reserved.
-
-   License to copy and use this software is granted provided that it
-   is identified as the "RSA Data Security, Inc. MD5 Message-Digest
-   Algorithm" in all material mentioning or referencing this software
-   or this function.
-
-   License is also granted to make and use derivative works provided
-   that such works are identified as "derived from the RSA Data
-   Security, Inc. MD5 Message-Digest Algorithm" in all material
-   mentioning or referencing the derived work.
-
-   RSA Data Security, Inc. makes no representations concerning either
-   the merchantability of this software or the suitability of this
-   software for any particular purpose. It is provided "as is"
-   without express or implied warranty of any kind.
-
-   These notices must be retained in any copies of any part of this
-   documentation and/or software.
- */
-/*
- * The apr_md5_encode() routine uses much code obtained from the FreeBSD 3.0
- * MD5 crypt() function, which is licenced as follows:
- * ----------------------------------------------------------------------------
- * "THE BEER-WARE LICENSE" (Revision 42):
- * <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
- * can do whatever you want with this stuff. If we meet some day, and you think
- * this stuff is worth it, you can buy me a beer in return.  Poul-Henning Kamp
- * ----------------------------------------------------------------------------
- */
-
-For the srclib\apr-util\crypto\apr_md4.c component:
-
- * This is derived from material copyright RSA Data Security, Inc.
- * Their notice is reproduced below in its entirety.
- *
- * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
- * rights reserved.
- *
- * License to copy and use this software is granted provided that it
- * is identified as the "RSA Data Security, Inc. MD4 Message-Digest
- * Algorithm" in all material mentioning or referencing this software
- * or this function.
- *
- * License is also granted to make and use derivative works provided
- * that such works are identified as "derived from the RSA Data
- * Security, Inc. MD4 Message-Digest Algorithm" in all material
- * mentioning or referencing the derived work.
- *
- * RSA Data Security, Inc. makes no representations concerning either
- * the merchantability of this software or the suitability of this
- * software for any particular purpose. It is provided "as is"
- * without express or implied warranty of any kind.
- *
- * These notices must be retained in any copies of any part of this
- * documentation and/or software.
- */
-
-For the srclib\apr-util\include\apr_md4.h component:
-
- *
- * This is derived from material copyright RSA Data Security, Inc.
- * Their notice is reproduced below in its entirety.
- *
- * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
- * rights reserved.
- *
- * License to copy and use this software is granted provided that it
- * is identified as the "RSA Data Security, Inc. MD4 Message-Digest
- * Algorithm" in all material mentioning or referencing this software
- * or this function.
- *
- * License is also granted to make and use derivative works provided
- * that such works are identified as "derived from the RSA Data
- * Security, Inc. MD4 Message-Digest Algorithm" in all material
- * mentioning or referencing the derived work.
- *
- * RSA Data Security, Inc. makes no representations concerning either
- * the merchantability of this software or the suitability of this
- * software for any particular purpose. It is provided "as is"
- * without express or implied warranty of any kind.
- *
- * These notices must be retained in any copies of any part of this
- * documentation and/or software.
- */
-
-
-For the srclib\apr-util\test\testmd4.c component:
-
- *
- * This is derived from material copyright RSA Data Security, Inc.
- * Their notice is reproduced below in its entirety.
- *
- * Copyright (C) 1990-2, RSA Data Security, Inc. Created 1990. All
- * rights reserved.
- *
- * RSA Data Security, Inc. makes no representations concerning either
- * the merchantability of this software or the suitability of this
- * software for any particular purpose. It is provided "as is"
- * without express or implied warranty of any kind.
- *
- * These notices must be retained in any copies of any part of this
- * documentation and/or software.
- */
-
-For the srclib\apr-util\xml\expat\conftools\install-sh component:
-
-#
-# install - install a program, script, or datafile
-# This comes from X11R5 (mit/util/scripts/install.sh).
-#
-# Copyright 1991 by the Massachusetts Institute of Technology
-#
-# Permission to use, copy, modify, distribute, and sell this software and its
-# documentation for any purpose is hereby granted without fee, provided that
-# the above copyright notice appear in all copies and that both that
-# copyright notice and this permission notice appear in supporting
-# documentation, and that the name of M.I.T. not be used in advertising or
-# publicity pertaining to distribution of the software without specific,
-# written prior permission.  M.I.T. makes no representations about the
-# suitability of this software for any purpose.  It is provided "as is"
-# without express or implied warranty.
-#
-
-For the test\zb.c component:
-
-/*                          ZeusBench V1.01
-			    ===============
-
-This program is Copyright (C) Zeus Technology Limited 1996.
-
-This program may be used and copied freely providing this copyright notice
-is not removed.
-
-This software is provided "as is" and any express or implied waranties, 
-including but not limited to, the implied warranties of merchantability and
-fitness for a particular purpose are disclaimed.  In no event shall 
-Zeus Technology Ltd. be liable for any direct, indirect, incidental, special, 
-exemplary, or consequential damaged (including, but not limited to, 
-procurement of substitute good or services; loss of use, data, or profits;
-or business interruption) however caused and on theory of liability.  Whether
-in contract, strict liability or tort (including negligence or otherwise) 
-arising in any way out of the use of this software, even if advised of the
-possibility of such damage.
-
-     Written by Adam Twiss (adam@zeus.co.uk).  March 1996
-
-Thanks to the following people for their input:
-  Mike Belshe (mbelshe@netscape.com) 
-  Michael Campanella (campanella@stevms.enet.dec.com)
-
-*/
-
-For the expat xml parser component:
-
-Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
-                               and Clark Cooper
-
-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.
-
-====================================================================

README.md

@@ -1,85 +1,41 @@
-GAM, the Google Apps Manager
-============================
+GAM is a command line tool for Google Workspace admins to manage domain and user settings quickly and easily.
 
-Dito GAM is a free, open source command line tool for
-Google Apps Administrators to efficiently manage
-domain and user settings quickly and easily. GAM has support
-for many features, such as
+![Build Status](https://github.com/GAM-team/GAM/workflows/Build%20and%20test%20GAM/badge.svg)
 
-* creating, deleting, and updating users, aliases, groups, 
-  organizations, and resource calendars
-* modifying user email settings such as IMAP, signatures,
-  vacation messages, profile sharing, email forwarding,
-  send as address, labels, and features.
-* delegating mailboxes and calendars to other users
-* modifying calendar access rights for users and resource calendars.
-* auditing user accounts and mailboes
-* monitoring incoming and outgoing email
-* generating detailed reports for users, groups, resources,
-  account activity, email clients, and quotas.
+# Quick Start
 
+## Linux / MacOS
 
-Resources
-========
+Open a terminal and run:
 
-There are a number of GAM resources available via several different
-websites.
+```sh
+bash <(curl -s -S -L https://gam-shortn.appspot.com/gam-install)
+```
 
-Source Repository
------------------
+this will download GAM, install it and start setup.
 
-The official GAM source repository is on [Github][github].
+## Windows
 
+Download the MSI Installer from the [GitHub Releases] page. Install the MSI and you'll be prompted to setup GAM.
 
-Downloads
----------
+# Documentation
 
-You can download current and pre-released versions of GAM from 
-the [Github Releases][github releases] page.  Final releases
-are also available on [Google Drive][google drive]
+The GAM documentation is hosted in the [GitHub Wiki]
 
+# Mailing List / Discussion group
 
-Wiki Documentation
-----
+The GAM mailing list / discussion group is hosted on [Google Groups].  You can join the list and interact via email, or just post from the web itself.
 
-The GAM documentation is currently hosted on Google Code
-and can be found at the [Gam Getting Started Wiki][gam wiki]
+# Chat Room
 
-Mailing List / Discussion group
--------------------------------
+There is a public chat room hosted in Google Chat. [Instructions to join](https://github.com/GAM-team/GAM/wiki/GAM-Public-Chat-Room).
 
-The GAM mailing list / discussion group is hosted
-on [Google Groups].  You can join the list and interact
-via email, or just post from the web itself.
+# Author
 
+GAM is maintained by [Jay Lee](mailto:jay0lee@gmail.com). Please direct "how do I?" questions to [Google Groups].
 
-Author
-======
-
-GAM is maintained by <a href="mailto:jay0lee@gmail.com">Jay Lee</a>.
-
-THANKS TO
-=========
-
-GAM is made possible and maintained by the work of Dito.
-Who is Dito?
-
-Dito is solely focused on moving organizations to Google's
-cloud. After hundreds of successful deployments over the
-last 5 years, we have gained notoriety for our complete
-understanding of the platform, our change management &
-training ability, and our rock-star deployment engineers.
-We are known worldwide as the Google Apps Experts.
-
-Need a Google Apps Expert? 
-[Contact Dito](http://ditoweb.com/contact), which offers
-[free premium GAM support](http://www.ditoweb.com/dito-gam)
-for domains that sign up through Dito.
-
-
-[github releases]: https://github.com/jay0lee/GAM/releases
-[github]: https://github.com/jay0lee/GAM/
-[google code downloads]: https://code.google.com/p/google-apps-manager/wiki/Downloads
-[google drive]: https://googledrive.com/host/0B0YvUuHHn3MnbFl6N0k1UXcwdVk/
-[gam wiki]: https://code.google.com/p/google-apps-manager/wiki/GAM3GettingStarted
-[google groups]: http://groups.google.com/group/google-apps-manager
+[GAM release]: https://github.com/GAM-team/GAM/releases
+[GitHub Releases]: https://github.com/GAM-team/GAM/releases
+[GitHub]: https://github.com/GAM-team/GAM/tree/master
+[GitHub Wiki]: https://github.com/GAM-team/GAM/wiki/
+[Google Groups]: http://groups.google.com/group/google-apps-manager

admin-settings-v1.json

@@ -1,642 +0,0 @@
-{
- "kind": "discovery#restDescription",
- "discoveryVersion": "v1",
- "id": "admin-settings:v1",
- "name": "admin-settings",
- "version": "v1",
- "revision": "20130823",
- "title": "Admin Settings API (read-only calls)",
- "description": "Lets you access Google Apps Admin Settings",
- "ownerDomain": "google.com",
- "ownerName": "Google",
- "icons": {
-  "x16": "http://www.google.com/images/icons/product/search-16.gif",
-  "x32": "http://www.google.com/images/icons/product/search-32.gif"
- },
- "documentationLink": "https://developers.google.com/admin-sdk/admin-settings",
- "protocol": "rest",
- "baseUrl": "https://apps-apis.google.com/",
- "basePath": "/a/feeds/domain/2.0/",
- "rootUrl": "https://apps-apis.google.com/",
- "servicePath": "/a/feeds/domain/2.0/",
- "parameters": {
-  "v": {
-   "type": "string",
-   "description": "GData Version",
-   "default": "2.0",
-   "enum": [
-    "2.0"
-   ],
-   "enumDescriptions": [
-    "GData 2.0"
-   ],
-   "location": "query"
-  },
-  "alt": {
-   "type": "string",
-   "description": "Data format for the response.",
-   "default": "json",
-   "enum": [
-    "json"
-   ],
-   "enumDescriptions": [
-    "Responses with Content-Type of application/json"
-   ],
-   "location": "query"
-  },
-  "quotaUser": {
-   "type": "string",
-   "description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters. Overrides userIp if both are provided.",
-   "location": "query"
-  },
-  "prettyPrint": {
-   "type": "boolean",
-   "description": "Returns response with indentations and line breaks.",
-   "default": "true",
-   "location": "query"
-  }
- },
- "auth": {
-  "oauth2": {
-   "scopes": {
-    "https://apps-apis.google.com/a/feeds/domain/": {
-     "description": "Manage domain settings"
-    }
-   }
-  }
- },
- "schemas": {
-  "DefaultLanguage": {
-   "id": "DefaultLanguage",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "default language value"
-      }
-     }
-    }
-   }
-  },
-  "OrganizationName": {
-   "id": "OrganizationName",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "organization name value"
-      }
-     }
-    }
-   }
-  },
-  "MaximumNumberOfUsers": {
-   "id": "MaximumNumberOfUsers",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "maximum number of users value"
-      }
-     }
-    }
-   }
-  },
-  "CurrentNumberOfUsers": {
-   "id": "CurrentNumbersOfUsers",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "current number of users value"
-      }
-     }
-    }
-   }
-  },
-  "IsVerified": {
-   "id": "IsVerified",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "boolean",
-        "description": "current verification status value"
-      }
-     }
-    }
-   }
-  },
-  "Edition": {
-   "id": "Edition",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "domain edition value"
-      }
-     }
-    }
-   }
-  },
-  "CustomerPIN": {
-   "id": "CustomerPIN",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "customer pin value"
-      }
-     }
-    }
-   }
-  },
-  "CreationTime": {
-   "id": "CreationTime",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "domain creation time value"
-      }
-     }
-    }
-   }
-  },
-  "CountryCode": {
-   "id": "CountryCode",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "domain country code value"
-      }
-     }
-    }
-   }
-  },
-  "AdminSecondaryEmail": {
-   "id": "AdminSecondaryEmail",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "admin secondary email value"
-      }
-     }
-    }
-   }
-  },
-  "MXVerification": {
-   "id": "MXVerification",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "domain mx verification value"
-      }
-     }
-    }
-   }
-  },
-  "SSOGeneral": {
-   "id": "SSOGeneral",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "domain sso general value"
-      }
-     }
-    }
-   }
-  },
-  "SSOSigningKey": {
-   "id": "SSOSigningKey",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "domain sso signing key value"
-      }
-     }
-    }
-   }
-  },
-  "UserEmailMigrationEnabled": {
-   "id": "UserEmailMigrationEnabled",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "user email migration enabled value"
-      }
-     }
-    }
-   }
-  },
-  "OutboundGateway": {
-   "id": "OutboundGateway",
-   "type": "object",
-   "properties": {
-    "apps$property": {
-     "type": "object",
-     "properties": {
-      "name": {
-       "type": "string",
-       "description": "property name"
-      },
-      "value": {
-        "type": "string",
-        "description": "domain outbound gateway value"
-      }
-     }
-    }
-   }
-  }
- },
- "resources": {
-  "defaultLanguage": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.defaultLanguage.get",
-     "path": "{domainName}/general/defaultLanguage",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "DefaultLanguage"
-     }
-    }
-   }
-  },
-  "organizationName": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.organizationName.get",
-     "path": "{domainName}/general/organizationName",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "OrganizationName"
-     }
-    }
-   }
-  },
-  "maximumNumberOfUsers": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.maximumNumberOfUsers.get",
-     "path": "{domainName}/general/maximumNumberOfUsers",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "MaximumNumberOfUsers"
-     }
-    }
-   }
-  },
-  "currentNumberOfUsers": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.currentNumberOfUsers.get",
-     "path": "{domainName}/general/currentNumberOfUsers",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "CurrentNumberOfUsers"
-     }
-    }
-   }
-  },
-  "isVerified": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.isVerified.get",
-     "path": "{domainName}/accountInformation/isVerified",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "IsVerified"
-     }
-    }
-   }
-  },
-  "edition": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.edition.get",
-     "path": "{domainName}/accountInformation/edition",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "Edition"
-     }
-    }
-   }
-  },
-  "customerPIN": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.customerPIN.get",
-     "path": "{domainName}/accountInformation/customerPIN",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "CustomerPIN"
-     }
-    }
-   }
-  },
-  "creationTime": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.creationTime.get",
-     "path": "{domainName}/accountInformation/creationTime",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "CreationTime"
-     }
-    }
-   }
-  },
-  "countryCode": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.countryCode.get",
-     "path": "{domainName}/accountInformation/countryCode",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "CountryCode"
-     }
-    }
-   }
-  },
-  "adminSecondaryEmail": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.adminSecondaryEmail.get",
-     "path": "{domainName}/accountInformation/adminSecondaryEmail",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "AdminSecondaryEmail"
-     }
-    }
-   }
-  },
-  "mxVerification": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.mxVerification.get",
-     "path": "{domainName}/verification/mx",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "MXVerification"
-     }
-    }
-   }
-  },
-  "ssoGeneral": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.ssoGeneral.get",
-     "path": "{domainName}/sso/general",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "SSOGeneral"
-     }
-    }
-   }
-  },
-  "ssoSigningKey": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.ssoSigningKey.get",
-     "path": "{domainName}/sso/signingkey",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "SSOSigningKey"
-     }
-    }
-   }
-  },
-  "userEmailMigrationEnabled": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.userEmailMigrationEnabled.get",
-     "path": "{domainName}/email/migration",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "UserEmailMigrationEnabled"
-     }
-    }
-   }
-  },
-  "outboundGateway": {
-   "methods": {
-    "get": {
-     "id": "admin-settings.outboundGateway.get",
-     "path": "{domainName}/email/gateway",
-     "httpMethod": "GET",
-     "parameters": {
-      "domainName": {
-       "type": "string",
-       "required": "true",
-       "location": "path"
-      }
-     },
-     "response": {
-      "$ref": "OutboundGateway"
-     }
-    }
-   }
-  }
- }
-}

apiclient/__init__.py

@@ -1,15 +0,0 @@
-# Copyright (C) 2012 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-__version__ = "1.2"

apiclient/channel.py

@@ -1,285 +0,0 @@
-"""Channel notifications support.
-
-Classes and functions to support channel subscriptions and notifications
-on those channels.
-
-Notes:
-  - This code is based on experimental APIs and is subject to change.
-  - Notification does not do deduplication of notification ids, that's up to
-    the receiver.
-  - Storing the Channel between calls is up to the caller.
-
-
-Example setting up a channel:
-
-  # Create a new channel that gets notifications via webhook.
-  channel = new_webhook_channel("https://example.com/my_web_hook")
-
-  # Store the channel, keyed by 'channel.id'. Store it before calling the
-  # watch method because notifications may start arriving before the watch
-  # method returns.
-  ...
-
-  resp = service.objects().watchAll(
-    bucket="some_bucket_id", body=channel.body()).execute()
-  channel.update(resp)
-
-  # Store the channel, keyed by 'channel.id'. Store it after being updated
-  # since the resource_id value will now be correct, and that's needed to
-  # stop a subscription.
-  ...
-
-
-An example Webhook implementation using webapp2. Note that webapp2 puts
-headers in a case insensitive dictionary, as headers aren't guaranteed to
-always be upper case.
-
-  id = self.request.headers[X_GOOG_CHANNEL_ID]
-
-  # Retrieve the channel by id.
-  channel = ...
-
-  # Parse notification from the headers, including validating the id.
-  n = notification_from_headers(channel, self.request.headers)
-
-  # Do app specific stuff with the notification here.
-  if n.resource_state == 'sync':
-    # Code to handle sync state.
-  elif n.resource_state == 'exists':
-    # Code to handle the exists state.
-  elif n.resource_state == 'not_exists':
-    # Code to handle the not exists state.
-
-
-Example of unsubscribing.
-
-  service.channels().stop(channel.body())
-"""
-
-import datetime
-import uuid
-
-from apiclient import errors
-from oauth2client import util
-
-
-# The unix time epoch starts at midnight 1970.
-EPOCH = datetime.datetime.utcfromtimestamp(0)
-
-# Map the names of the parameters in the JSON channel description to
-# the parameter names we use in the Channel class.
-CHANNEL_PARAMS = {
-    'address': 'address',
-    'id': 'id',
-    'expiration': 'expiration',
-    'params': 'params',
-    'resourceId': 'resource_id',
-    'resourceUri': 'resource_uri',
-    'type': 'type',
-    'token': 'token',
-    }
-
-X_GOOG_CHANNEL_ID     = 'X-GOOG-CHANNEL-ID'
-X_GOOG_MESSAGE_NUMBER = 'X-GOOG-MESSAGE-NUMBER'
-X_GOOG_RESOURCE_STATE = 'X-GOOG-RESOURCE-STATE'
-X_GOOG_RESOURCE_URI   = 'X-GOOG-RESOURCE-URI'
-X_GOOG_RESOURCE_ID    = 'X-GOOG-RESOURCE-ID'
-
-
-def _upper_header_keys(headers):
-  new_headers = {}
-  for k, v in headers.iteritems():
-    new_headers[k.upper()] = v
-  return new_headers
-
-
-class Notification(object):
-  """A Notification from a Channel.
-
-  Notifications are not usually constructed directly, but are returned
-  from functions like notification_from_headers().
-
-  Attributes:
-    message_number: int, The unique id number of this notification.
-    state: str, The state of the resource being monitored.
-    uri: str, The address of the resource being monitored.
-    resource_id: str, The unique identifier of the version of the resource at
-      this event.
-  """
-  @util.positional(5)
-  def __init__(self, message_number, state, resource_uri, resource_id):
-    """Notification constructor.
-
-    Args:
-      message_number: int, The unique id number of this notification.
-      state: str, The state of the resource being monitored. Can be one
-        of "exists", "not_exists", or "sync".
-      resource_uri: str, The address of the resource being monitored.
-      resource_id: str, The identifier of the watched resource.
-    """
-    self.message_number = message_number
-    self.state = state
-    self.resource_uri = resource_uri
-    self.resource_id = resource_id
-
-
-class Channel(object):
-  """A Channel for notifications.
-
-  Usually not constructed directly, instead it is returned from helper
-  functions like new_webhook_channel().
-
-  Attributes:
-    type: str, The type of delivery mechanism used by this channel. For
-      example, 'web_hook'.
-    id: str, A UUID for the channel.
-    token: str, An arbitrary string associated with the channel that
-      is delivered to the target address with each event delivered
-      over this channel.
-    address: str, The address of the receiving entity where events are
-      delivered. Specific to the channel type.
-    expiration: int, The time, in milliseconds from the epoch, when this
-      channel will expire.
-    params: dict, A dictionary of string to string, with additional parameters
-      controlling delivery channel behavior.
-    resource_id: str, An opaque id that identifies the resource that is
-      being watched. Stable across different API versions.
-    resource_uri: str, The canonicalized ID of the watched resource.
-  """
-
-  @util.positional(5)
-  def __init__(self, type, id, token, address, expiration=None,
-               params=None, resource_id="", resource_uri=""):
-    """Create a new Channel.
-
-    In user code, this Channel constructor will not typically be called
-    manually since there are functions for creating channels for each specific
-    type with a more customized set of arguments to pass.
-
-    Args:
-      type: str, The type of delivery mechanism used by this channel. For
-        example, 'web_hook'.
-      id: str, A UUID for the channel.
-      token: str, An arbitrary string associated with the channel that
-        is delivered to the target address with each event delivered
-        over this channel.
-      address: str,  The address of the receiving entity where events are
-        delivered. Specific to the channel type.
-      expiration: int, The time, in milliseconds from the epoch, when this
-        channel will expire.
-      params: dict, A dictionary of string to string, with additional parameters
-        controlling delivery channel behavior.
-      resource_id: str, An opaque id that identifies the resource that is
-        being watched. Stable across different API versions.
-      resource_uri: str, The canonicalized ID of the watched resource.
-    """
-    self.type = type
-    self.id = id
-    self.token = token
-    self.address = address
-    self.expiration = expiration
-    self.params = params
-    self.resource_id = resource_id
-    self.resource_uri = resource_uri
-
-  def body(self):
-    """Build a body from the Channel.
-
-    Constructs a dictionary that's appropriate for passing into watch()
-    methods as the value of body argument.
-
-    Returns:
-      A dictionary representation of the channel.
-    """
-    result = {
-        'id': self.id,
-        'token': self.token,
-        'type': self.type,
-        'address': self.address
-        }
-    if self.params:
-      result['params'] = self.params
-    if self.resource_id:
-      result['resourceId'] = self.resource_id
-    if self.resource_uri:
-      result['resourceUri'] = self.resource_uri
-    if self.expiration:
-      result['expiration'] = self.expiration
-
-    return result
-
-  def update(self, resp):
-    """Update a channel with information from the response of watch().
-
-    When a request is sent to watch() a resource, the response returned
-    from the watch() request is a dictionary with updated channel information,
-    such as the resource_id, which is needed when stopping a subscription.
-
-    Args:
-      resp: dict, The response from a watch() method.
-    """
-    for json_name, param_name in CHANNEL_PARAMS.iteritems():
-      value = resp.get(json_name)
-      if value is not None:
-        setattr(self, param_name, value)
-
-
-def notification_from_headers(channel, headers):
-  """Parse a notification from the webhook request headers, validate
-    the notification, and return a Notification object.
-
-  Args:
-    channel: Channel, The channel that the notification is associated with.
-    headers: dict, A dictionary like object that contains the request headers
-      from the webhook HTTP request.
-
-  Returns:
-    A Notification object.
-
-  Raises:
-    errors.InvalidNotificationError if the notification is invalid.
-    ValueError if the X-GOOG-MESSAGE-NUMBER can't be converted to an int.
-  """
-  headers = _upper_header_keys(headers)
-  channel_id = headers[X_GOOG_CHANNEL_ID]
-  if channel.id != channel_id:
-    raise errors.InvalidNotificationError(
-        'Channel id mismatch: %s != %s' % (channel.id, channel_id))
-  else:
-    message_number = int(headers[X_GOOG_MESSAGE_NUMBER])
-    state = headers[X_GOOG_RESOURCE_STATE]
-    resource_uri = headers[X_GOOG_RESOURCE_URI]
-    resource_id = headers[X_GOOG_RESOURCE_ID]
-    return Notification(message_number, state, resource_uri, resource_id)
-
-
-@util.positional(2)
-def new_webhook_channel(url, token=None, expiration=None, params=None):
-    """Create a new webhook Channel.
-
-    Args:
-      url: str, URL to post notifications to.
-      token: str, An arbitrary string associated with the channel that
-        is delivered to the target address with each notification delivered
-        over this channel.
-      expiration: datetime.datetime, A time in the future when the channel
-        should expire. Can also be None if the subscription should use the
-        default expiration. Note that different services may have different
-        limits on how long a subscription lasts. Check the response from the
-        watch() method to see the value the service has set for an expiration
-        time.
-      params: dict, Extra parameters to pass on channel creation. Currently
-        not used for webhook channels.
-    """
-    expiration_ms = 0
-    if expiration:
-      delta = expiration - EPOCH
-      expiration_ms = delta.microseconds/1000 + (
-          delta.seconds + delta.days*24*3600)*1000
-      if expiration_ms < 0:
-        expiration_ms = 0
-
-    return Channel('web_hook', str(uuid.uuid4()),
-                   token, url, expiration=expiration_ms,
-                   params=params)
-

apiclient/discovery.py

@@ -1,963 +0,0 @@
-# Copyright (C) 2010 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Client for discovery based APIs.
-
-A client library for Google's discovery based APIs.
-"""
-
-__author__ = 'jcgregorio@google.com (Joe Gregorio)'
-__all__ = [
-    'build',
-    'build_from_document',
-    'fix_method_name',
-    'key2param',
-    ]
-
-
-# Standard library imports
-import copy
-from email.mime.multipart import MIMEMultipart
-from email.mime.nonmultipart import MIMENonMultipart
-import keyword
-import logging
-import mimetypes
-import os
-import re
-import urllib
-import urlparse
-
-try:
-  from urlparse import parse_qsl
-except ImportError:
-  from cgi import parse_qsl
-
-# Third-party imports
-import httplib2
-import mimeparse
-import uritemplate
-
-# Local imports
-from apiclient.errors import HttpError
-from apiclient.errors import InvalidJsonError
-from apiclient.errors import MediaUploadSizeError
-from apiclient.errors import UnacceptableMimeTypeError
-from apiclient.errors import UnknownApiNameOrVersion
-from apiclient.errors import UnknownFileType
-from apiclient.http import HttpRequest
-from apiclient.http import MediaFileUpload
-from apiclient.http import MediaUpload
-from apiclient.model import JsonModel
-from apiclient.model import MediaModel
-from apiclient.model import RawModel
-from apiclient.schema import Schemas
-from oauth2client.anyjson import simplejson
-from oauth2client.util import _add_query_parameter
-from oauth2client.util import positional
-
-
-# The client library requires a version of httplib2 that supports RETRIES.
-httplib2.RETRIES = 1
-
-logger = logging.getLogger(__name__)
-
-URITEMPLATE = re.compile('{[^}]*}')
-VARNAME = re.compile('[a-zA-Z0-9_-]+')
-if httplib2.debuglevel > 0:
-  prettyPrint = 'true'
-else:
-  prettyPrint = 'false'
-DISCOVERY_URI = ('https://www.googleapis.com/discovery/v1/apis/'
-                 '{api}/{apiVersion}/rest?prettyPrint=%s' % prettyPrint)
-DEFAULT_METHOD_DOC = 'A description of how to use this function'
-HTTP_PAYLOAD_METHODS = frozenset(['PUT', 'POST', 'PATCH'])
-_MEDIA_SIZE_BIT_SHIFTS = {'KB': 10, 'MB': 20, 'GB': 30, 'TB': 40}
-BODY_PARAMETER_DEFAULT_VALUE = {
-    'description': 'The request body.',
-    'type': 'object',
-    'required': True,
-}
-MEDIA_BODY_PARAMETER_DEFAULT_VALUE = {
-    'description': ('The filename of the media request body, or an instance '
-                    'of a MediaUpload object.'),
-    'type': 'string',
-    'required': False,
-}
-
-# Parameters accepted by the stack, but not visible via discovery.
-# TODO(dhermes): Remove 'userip' in 'v2'.
-STACK_QUERY_PARAMETERS = frozenset(['trace', 'pp', 'userip', 'strict'])
-STACK_QUERY_PARAMETER_DEFAULT_VALUE = {'type': 'string', 'location': 'query'}
-
-# Library-specific reserved words beyond Python keywords.
-RESERVED_WORDS = frozenset(['body'])
-
-
-def fix_method_name(name):
-  """Fix method names to avoid reserved word conflicts.
-
-  Args:
-    name: string, method name.
-
-  Returns:
-    The name with a '_' prefixed if the name is a reserved word.
-  """
-  if keyword.iskeyword(name) or name in RESERVED_WORDS:
-    return name + '_'
-  else:
-    return name
-
-
-def key2param(key):
-  """Converts key names into parameter names.
-
-  For example, converting "max-results" -> "max_results"
-
-  Args:
-    key: string, the method key name.
-
-  Returns:
-    A safe method name based on the key name.
-  """
-  result = []
-  key = list(key)
-  if not key[0].isalpha():
-    result.append('x')
-  for c in key:
-    if c.isalnum():
-      result.append(c)
-    else:
-      result.append('_')
-
-  return ''.join(result)
-
-
-@positional(2)
-def build(serviceName,
-          version,
-          http=None,
-          discoveryServiceUrl=DISCOVERY_URI,
-          developerKey=None,
-          model=None,
-          requestBuilder=HttpRequest):
-  """Construct a Resource for interacting with an API.
-
-  Construct a Resource object for interacting with an API. The serviceName and
-  version are the names from the Discovery service.
-
-  Args:
-    serviceName: string, name of the service.
-    version: string, the version of the service.
-    http: httplib2.Http, An instance of httplib2.Http or something that acts
-      like it that HTTP requests will be made through.
-    discoveryServiceUrl: string, a URI Template that points to the location of
-      the discovery service. It should have two parameters {api} and
-      {apiVersion} that when filled in produce an absolute URI to the discovery
-      document for that service.
-    developerKey: string, key obtained from
-      https://code.google.com/apis/console.
-    model: apiclient.Model, converts to and from the wire format.
-    requestBuilder: apiclient.http.HttpRequest, encapsulator for an HTTP
-      request.
-
-  Returns:
-    A Resource object with methods for interacting with the service.
-  """
-  params = {
-      'api': serviceName,
-      'apiVersion': version
-      }
-
-  if http is None:
-    http = httplib2.Http()
-
-  requested_url = uritemplate.expand(discoveryServiceUrl, params)
-
-  # REMOTE_ADDR is defined by the CGI spec [RFC3875] as the environment
-  # variable that contains the network address of the client sending the
-  # request. If it exists then add that to the request for the discovery
-  # document to avoid exceeding the quota on discovery requests.
-  if 'REMOTE_ADDR' in os.environ:
-    requested_url = _add_query_parameter(requested_url, 'userIp',
-                                         os.environ['REMOTE_ADDR'])
-  logger.info('URL being requested: %s' % requested_url)
-
-  resp, content = http.request(requested_url)
-
-  if resp.status == 404:
-    raise UnknownApiNameOrVersion("name: %s  version: %s" % (serviceName,
-                                                            version))
-  if resp.status >= 400:
-    raise HttpError(resp, content, uri=requested_url)
-
-  try:
-    service = simplejson.loads(content)
-  except ValueError, e:
-    logger.error('Failed to parse as JSON: ' + content)
-    raise InvalidJsonError()
-
-  return build_from_document(content, base=discoveryServiceUrl, http=http,
-      developerKey=developerKey, model=model, requestBuilder=requestBuilder)
-
-
-@positional(1)
-def build_from_document(
-    service,
-    base=None,
-    future=None,
-    http=None,
-    developerKey=None,
-    model=None,
-    requestBuilder=HttpRequest):
-  """Create a Resource for interacting with an API.
-
-  Same as `build()`, but constructs the Resource object from a discovery
-  document that is it given, as opposed to retrieving one over HTTP.
-
-  Args:
-    service: string or object, the JSON discovery document describing the API.
-      The value passed in may either be the JSON string or the deserialized
-      JSON.
-    base: string, base URI for all HTTP requests, usually the discovery URI.
-      This parameter is no longer used as rootUrl and servicePath are included
-      within the discovery document. (deprecated)
-    future: string, discovery document with future capabilities (deprecated).
-    http: httplib2.Http, An instance of httplib2.Http or something that acts
-      like it that HTTP requests will be made through.
-    developerKey: string, Key for controlling API usage, generated
-      from the API Console.
-    model: Model class instance that serializes and de-serializes requests and
-      responses.
-    requestBuilder: Takes an http request and packages it up to be executed.
-
-  Returns:
-    A Resource object with methods for interacting with the service.
-  """
-
-  # future is no longer used.
-  future = {}
-
-  if isinstance(service, basestring):
-    service = simplejson.loads(service)
-  base = urlparse.urljoin(service['rootUrl'], service['servicePath'])
-  schema = Schemas(service)
-
-  if model is None:
-    features = service.get('features', [])
-    model = JsonModel('dataWrapper' in features)
-  return Resource(http=http, baseUrl=base, model=model,
-                  developerKey=developerKey, requestBuilder=requestBuilder,
-                  resourceDesc=service, rootDesc=service, schema=schema)
-
-
-def _cast(value, schema_type):
-  """Convert value to a string based on JSON Schema type.
-
-  See http://tools.ietf.org/html/draft-zyp-json-schema-03 for more details on
-  JSON Schema.
-
-  Args:
-    value: any, the value to convert
-    schema_type: string, the type that value should be interpreted as
-
-  Returns:
-    A string representation of 'value' based on the schema_type.
-  """
-  if schema_type == 'string':
-    if type(value) == type('') or type(value) == type(u''):
-      return value
-    else:
-      return str(value)
-  elif schema_type == 'integer':
-    return str(int(value))
-  elif schema_type == 'number':
-    return str(float(value))
-  elif schema_type == 'boolean':
-    return str(bool(value)).lower()
-  else:
-    if type(value) == type('') or type(value) == type(u''):
-      return value
-    else:
-      return str(value)
-
-
-def _media_size_to_long(maxSize):
-  """Convert a string media size, such as 10GB or 3TB into an integer.
-
-  Args:
-    maxSize: string, size as a string, such as 2MB or 7GB.
-
-  Returns:
-    The size as an integer value.
-  """
-  if len(maxSize) < 2:
-    return 0L
-  units = maxSize[-2:].upper()
-  bit_shift = _MEDIA_SIZE_BIT_SHIFTS.get(units)
-  if bit_shift is not None:
-    return long(maxSize[:-2]) << bit_shift
-  else:
-    return long(maxSize)
-
-
-def _media_path_url_from_info(root_desc, path_url):
-  """Creates an absolute media path URL.
-
-  Constructed using the API root URI and service path from the discovery
-  document and the relative path for the API method.
-
-  Args:
-    root_desc: Dictionary; the entire original deserialized discovery document.
-    path_url: String; the relative URL for the API method. Relative to the API
-        root, which is specified in the discovery document.
-
-  Returns:
-    String; the absolute URI for media upload for the API method.
-  """
-  return '%(root)supload/%(service_path)s%(path)s' % {
-      'root': root_desc['rootUrl'],
-      'service_path': root_desc['servicePath'],
-      'path': path_url,
-  }
-
-
-def _fix_up_parameters(method_desc, root_desc, http_method):
-  """Updates parameters of an API method with values specific to this library.
-
-  Specifically, adds whatever global parameters are specified by the API to the
-  parameters for the individual method. Also adds parameters which don't
-  appear in the discovery document, but are available to all discovery based
-  APIs (these are listed in STACK_QUERY_PARAMETERS).
-
-  SIDE EFFECTS: This updates the parameters dictionary object in the method
-  description.
-
-  Args:
-    method_desc: Dictionary with metadata describing an API method. Value comes
-        from the dictionary of methods stored in the 'methods' key in the
-        deserialized discovery document.
-    root_desc: Dictionary; the entire original deserialized discovery document.
-    http_method: String; the HTTP method used to call the API method described
-        in method_desc.
-
-  Returns:
-    The updated Dictionary stored in the 'parameters' key of the method
-        description dictionary.
-  """
-  parameters = method_desc.setdefault('parameters', {})
-
-  # Add in the parameters common to all methods.
-  for name, description in root_desc.get('parameters', {}).iteritems():
-    parameters[name] = description
-
-  # Add in undocumented query parameters.
-  for name in STACK_QUERY_PARAMETERS:
-    parameters[name] = STACK_QUERY_PARAMETER_DEFAULT_VALUE.copy()
-
-  # Add 'body' (our own reserved word) to parameters if the method supports
-  # a request payload.
-  if http_method in HTTP_PAYLOAD_METHODS and 'request' in method_desc:
-    body = BODY_PARAMETER_DEFAULT_VALUE.copy()
-    body.update(method_desc['request'])
-    parameters['body'] = body
-
-  return parameters
-
-
-def _fix_up_media_upload(method_desc, root_desc, path_url, parameters):
-  """Updates parameters of API by adding 'media_body' if supported by method.
-
-  SIDE EFFECTS: If the method supports media upload and has a required body,
-  sets body to be optional (required=False) instead. Also, if there is a
-  'mediaUpload' in the method description, adds 'media_upload' key to
-  parameters.
-
-  Args:
-    method_desc: Dictionary with metadata describing an API method. Value comes
-        from the dictionary of methods stored in the 'methods' key in the
-        deserialized discovery document.
-    root_desc: Dictionary; the entire original deserialized discovery document.
-    path_url: String; the relative URL for the API method. Relative to the API
-        root, which is specified in the discovery document.
-    parameters: A dictionary describing method parameters for method described
-        in method_desc.
-
-  Returns:
-    Triple (accept, max_size, media_path_url) where:
-      - accept is a list of strings representing what content types are
-        accepted for media upload. Defaults to empty list if not in the
-        discovery document.
-      - max_size is a long representing the max size in bytes allowed for a
-        media upload. Defaults to 0L if not in the discovery document.
-      - media_path_url is a String; the absolute URI for media upload for the
-        API method. Constructed using the API root URI and service path from
-        the discovery document and the relative path for the API method. If
-        media upload is not supported, this is None.
-  """
-  media_upload = method_desc.get('mediaUpload', {})
-  accept = media_upload.get('accept', [])
-  max_size = _media_size_to_long(media_upload.get('maxSize', ''))
-  media_path_url = None
-
-  if media_upload:
-    media_path_url = _media_path_url_from_info(root_desc, path_url)
-    parameters['media_body'] = MEDIA_BODY_PARAMETER_DEFAULT_VALUE.copy()
-    if 'body' in parameters:
-      parameters['body']['required'] = False
-
-  return accept, max_size, media_path_url
-
-
-def _fix_up_method_description(method_desc, root_desc):
-  """Updates a method description in a discovery document.
-
-  SIDE EFFECTS: Changes the parameters dictionary in the method description with
-  extra parameters which are used locally.
-
-  Args:
-    method_desc: Dictionary with metadata describing an API method. Value comes
-        from the dictionary of methods stored in the 'methods' key in the
-        deserialized discovery document.
-    root_desc: Dictionary; the entire original deserialized discovery document.
-
-  Returns:
-    Tuple (path_url, http_method, method_id, accept, max_size, media_path_url)
-    where:
-      - path_url is a String; the relative URL for the API method. Relative to
-        the API root, which is specified in the discovery document.
-      - http_method is a String; the HTTP method used to call the API method
-        described in the method description.
-      - method_id is a String; the name of the RPC method associated with the
-        API method, and is in the method description in the 'id' key.
-      - accept is a list of strings representing what content types are
-        accepted for media upload. Defaults to empty list if not in the
-        discovery document.
-      - max_size is a long representing the max size in bytes allowed for a
-        media upload. Defaults to 0L if not in the discovery document.
-      - media_path_url is a String; the absolute URI for media upload for the
-        API method. Constructed using the API root URI and service path from
-        the discovery document and the relative path for the API method. If
-        media upload is not supported, this is None.
-  """
-  path_url = method_desc['path']
-  http_method = method_desc['httpMethod']
-  method_id = method_desc['id']
-
-  parameters = _fix_up_parameters(method_desc, root_desc, http_method)
-  # Order is important. `_fix_up_media_upload` needs `method_desc` to have a
-  # 'parameters' key and needs to know if there is a 'body' parameter because it
-  # also sets a 'media_body' parameter.
-  accept, max_size, media_path_url = _fix_up_media_upload(
-      method_desc, root_desc, path_url, parameters)
-
-  return path_url, http_method, method_id, accept, max_size, media_path_url
-
-
-# TODO(dhermes): Convert this class to ResourceMethod and make it callable
-class ResourceMethodParameters(object):
-  """Represents the parameters associated with a method.
-
-  Attributes:
-    argmap: Map from method parameter name (string) to query parameter name
-        (string).
-    required_params: List of required parameters (represented by parameter
-        name as string).
-    repeated_params: List of repeated parameters (represented by parameter
-        name as string).
-    pattern_params: Map from method parameter name (string) to regular
-        expression (as a string). If the pattern is set for a parameter, the
-        value for that parameter must match the regular expression.
-    query_params: List of parameters (represented by parameter name as string)
-        that will be used in the query string.
-    path_params: Set of parameters (represented by parameter name as string)
-        that will be used in the base URL path.
-    param_types: Map from method parameter name (string) to parameter type. Type
-        can be any valid JSON schema type; valid values are 'any', 'array',
-        'boolean', 'integer', 'number', 'object', or 'string'. Reference:
-        http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
-    enum_params: Map from method parameter name (string) to list of strings,
-       where each list of strings is the list of acceptable enum values.
-  """
-
-  def __init__(self, method_desc):
-    """Constructor for ResourceMethodParameters.
-
-    Sets default values and defers to set_parameters to populate.
-
-    Args:
-      method_desc: Dictionary with metadata describing an API method. Value
-          comes from the dictionary of methods stored in the 'methods' key in
-          the deserialized discovery document.
-    """
-    self.argmap = {}
-    self.required_params = []
-    self.repeated_params = []
-    self.pattern_params = {}
-    self.query_params = []
-    # TODO(dhermes): Change path_params to a list if the extra URITEMPLATE
-    #                parsing is gotten rid of.
-    self.path_params = set()
-    self.param_types = {}
-    self.enum_params = {}
-
-    self.set_parameters(method_desc)
-
-  def set_parameters(self, method_desc):
-    """Populates maps and lists based on method description.
-
-    Iterates through each parameter for the method and parses the values from
-    the parameter dictionary.
-
-    Args:
-      method_desc: Dictionary with metadata describing an API method. Value
-          comes from the dictionary of methods stored in the 'methods' key in
-          the deserialized discovery document.
-    """
-    for arg, desc in method_desc.get('parameters', {}).iteritems():
-      param = key2param(arg)
-      self.argmap[param] = arg
-
-      if desc.get('pattern'):
-        self.pattern_params[param] = desc['pattern']
-      if desc.get('enum'):
-        self.enum_params[param] = desc['enum']
-      if desc.get('required'):
-        self.required_params.append(param)
-      if desc.get('repeated'):
-        self.repeated_params.append(param)
-      if desc.get('location') == 'query':
-        self.query_params.append(param)
-      if desc.get('location') == 'path':
-        self.path_params.add(param)
-      self.param_types[param] = desc.get('type', 'string')
-
-    # TODO(dhermes): Determine if this is still necessary. Discovery based APIs
-    #                should have all path parameters already marked with
-    #                'location: path'.
-    for match in URITEMPLATE.finditer(method_desc['path']):
-      for namematch in VARNAME.finditer(match.group(0)):
-        name = key2param(namematch.group(0))
-        self.path_params.add(name)
-        if name in self.query_params:
-          self.query_params.remove(name)
-
-
-def createMethod(methodName, methodDesc, rootDesc, schema):
-  """Creates a method for attaching to a Resource.
-
-  Args:
-    methodName: string, name of the method to use.
-    methodDesc: object, fragment of deserialized discovery document that
-      describes the method.
-    rootDesc: object, the entire deserialized discovery document.
-    schema: object, mapping of schema names to schema descriptions.
-  """
-  methodName = fix_method_name(methodName)
-  (pathUrl, httpMethod, methodId, accept,
-   maxSize, mediaPathUrl) = _fix_up_method_description(methodDesc, rootDesc)
-
-  parameters = ResourceMethodParameters(methodDesc)
-
-  def method(self, **kwargs):
-    # Don't bother with doc string, it will be over-written by createMethod.
-
-    for name in kwargs.iterkeys():
-      if name not in parameters.argmap:
-        raise TypeError('Got an unexpected keyword argument "%s"' % name)
-
-    # Remove args that have a value of None.
-    keys = kwargs.keys()
-    for name in keys:
-      if kwargs[name] is None:
-        del kwargs[name]
-
-    for name in parameters.required_params:
-      if name not in kwargs:
-        raise TypeError('Missing required parameter "%s"' % name)
-
-    for name, regex in parameters.pattern_params.iteritems():
-      if name in kwargs:
-        if isinstance(kwargs[name], basestring):
-          pvalues = [kwargs[name]]
-        else:
-          pvalues = kwargs[name]
-        for pvalue in pvalues:
-          if re.match(regex, pvalue) is None:
-            raise TypeError(
-                'Parameter "%s" value "%s" does not match the pattern "%s"' %
-                (name, pvalue, regex))
-
-    for name, enums in parameters.enum_params.iteritems():
-      if name in kwargs:
-        # We need to handle the case of a repeated enum
-        # name differently, since we want to handle both
-        # arg='value' and arg=['value1', 'value2']
-        if (name in parameters.repeated_params and
-            not isinstance(kwargs[name], basestring)):
-          values = kwargs[name]
-        else:
-          values = [kwargs[name]]
-        for value in values:
-          if value not in enums:
-            raise TypeError(
-                'Parameter "%s" value "%s" is not an allowed value in "%s"' %
-                (name, value, str(enums)))
-
-    actual_query_params = {}
-    actual_path_params = {}
-    for key, value in kwargs.iteritems():
-      to_type = parameters.param_types.get(key, 'string')
-      # For repeated parameters we cast each member of the list.
-      if key in parameters.repeated_params and type(value) == type([]):
-        cast_value = [_cast(x, to_type) for x in value]
-      else:
-        cast_value = _cast(value, to_type)
-      if key in parameters.query_params:
-        actual_query_params[parameters.argmap[key]] = cast_value
-      if key in parameters.path_params:
-        actual_path_params[parameters.argmap[key]] = cast_value
-    body_value = kwargs.get('body', None)
-    media_filename = kwargs.get('media_body', None)
-
-    if self._developerKey:
-      actual_query_params['key'] = self._developerKey
-
-    model = self._model
-    if methodName.endswith('_media'):
-      model = MediaModel()
-    elif 'response' not in methodDesc:
-      model = RawModel()
-
-    headers = {}
-    headers, params, query, body = model.request(headers,
-        actual_path_params, actual_query_params, body_value)
-
-    expanded_url = uritemplate.expand(pathUrl, params)
-    url = urlparse.urljoin(self._baseUrl, expanded_url + query)
-
-    resumable = None
-    multipart_boundary = ''
-
-    if media_filename:
-      # Ensure we end up with a valid MediaUpload object.
-      if isinstance(media_filename, basestring):
-        (media_mime_type, encoding) = mimetypes.guess_type(media_filename)
-        if media_mime_type is None:
-          raise UnknownFileType(media_filename)
-        if not mimeparse.best_match([media_mime_type], ','.join(accept)):
-          raise UnacceptableMimeTypeError(media_mime_type)
-        media_upload = MediaFileUpload(media_filename,
-                                       mimetype=media_mime_type)
-      elif isinstance(media_filename, MediaUpload):
-        media_upload = media_filename
-      else:
-        raise TypeError('media_filename must be str or MediaUpload.')
-
-      # Check the maxSize
-      if maxSize > 0 and media_upload.size() > maxSize:
-        raise MediaUploadSizeError("Media larger than: %s" % maxSize)
-
-      # Use the media path uri for media uploads
-      expanded_url = uritemplate.expand(mediaPathUrl, params)
-      url = urlparse.urljoin(self._baseUrl, expanded_url + query)
-      if media_upload.resumable():
-        url = _add_query_parameter(url, 'uploadType', 'resumable')
-
-      if media_upload.resumable():
-        # This is all we need to do for resumable, if the body exists it gets
-        # sent in the first request, otherwise an empty body is sent.
-        resumable = media_upload
-      else:
-        # A non-resumable upload
-        if body is None:
-          # This is a simple media upload
-          headers['content-type'] = media_upload.mimetype()
-          body = media_upload.getbytes(0, media_upload.size())
-          url = _add_query_parameter(url, 'uploadType', 'media')
-        else:
-          # This is a multipart/related upload.
-          msgRoot = MIMEMultipart('related')
-          # msgRoot should not write out it's own headers
-          setattr(msgRoot, '_write_headers', lambda self: None)
-
-          # attach the body as one part
-          msg = MIMENonMultipart(*headers['content-type'].split('/'))
-          msg.set_payload(body)
-          msgRoot.attach(msg)
-
-          # attach the media as the second part
-          msg = MIMENonMultipart(*media_upload.mimetype().split('/'))
-          msg['Content-Transfer-Encoding'] = 'binary'
-
-          payload = media_upload.getbytes(0, media_upload.size())
-          msg.set_payload(payload)
-          msgRoot.attach(msg)
-          body = msgRoot.as_string()
-
-          multipart_boundary = msgRoot.get_boundary()
-          headers['content-type'] = ('multipart/related; '
-                                     'boundary="%s"') % multipart_boundary
-          url = _add_query_parameter(url, 'uploadType', 'multipart')
-
-    logger.info('URL being requested: %s' % url)
-    return self._requestBuilder(self._http,
-                                model.response,
-                                url,
-                                method=httpMethod,
-                                body=body,
-                                headers=headers,
-                                methodId=methodId,
-                                resumable=resumable)
-
-  docs = [methodDesc.get('description', DEFAULT_METHOD_DOC), '\n\n']
-  if len(parameters.argmap) > 0:
-    docs.append('Args:\n')
-
-  # Skip undocumented params and params common to all methods.
-  skip_parameters = rootDesc.get('parameters', {}).keys()
-  skip_parameters.extend(STACK_QUERY_PARAMETERS)
-
-  all_args = parameters.argmap.keys()
-  args_ordered = [key2param(s) for s in methodDesc.get('parameterOrder', [])]
-
-  # Move body to the front of the line.
-  if 'body' in all_args:
-    args_ordered.append('body')
-
-  for name in all_args:
-    if name not in args_ordered:
-      args_ordered.append(name)
-
-  for arg in args_ordered:
-    if arg in skip_parameters:
-      continue
-
-    repeated = ''
-    if arg in parameters.repeated_params:
-      repeated = ' (repeated)'
-    required = ''
-    if arg in parameters.required_params:
-      required = ' (required)'
-    paramdesc = methodDesc['parameters'][parameters.argmap[arg]]
-    paramdoc = paramdesc.get('description', 'A parameter')
-    if '$ref' in paramdesc:
-      docs.append(
-          ('  %s: object, %s%s%s\n    The object takes the'
-          ' form of:\n\n%s\n\n') % (arg, paramdoc, required, repeated,
-            schema.prettyPrintByName(paramdesc['$ref'])))
-    else:
-      paramtype = paramdesc.get('type', 'string')
-      docs.append('  %s: %s, %s%s%s\n' % (arg, paramtype, paramdoc, required,
-                                          repeated))
-    enum = paramdesc.get('enum', [])
-    enumDesc = paramdesc.get('enumDescriptions', [])
-    if enum and enumDesc:
-      docs.append('    Allowed values\n')
-      for (name, desc) in zip(enum, enumDesc):
-        docs.append('      %s - %s\n' % (name, desc))
-  if 'response' in methodDesc:
-    if methodName.endswith('_media'):
-      docs.append('\nReturns:\n  The media object as a string.\n\n    ')
-    else:
-      docs.append('\nReturns:\n  An object of the form:\n\n    ')
-      docs.append(schema.prettyPrintSchema(methodDesc['response']))
-
-  setattr(method, '__doc__', ''.join(docs))
-  return (methodName, method)
-
-
-def createNextMethod(methodName):
-  """Creates any _next methods for attaching to a Resource.
-
-  The _next methods allow for easy iteration through list() responses.
-
-  Args:
-    methodName: string, name of the method to use.
-  """
-  methodName = fix_method_name(methodName)
-
-  def methodNext(self, previous_request, previous_response):
-    """Retrieves the next page of results.
-
-Args:
-  previous_request: The request for the previous page. (required)
-  previous_response: The response from the request for the previous page. (required)
-
-Returns:
-  A request object that you can call 'execute()' on to request the next
-  page. Returns None if there are no more items in the collection.
-    """
-    # Retrieve nextPageToken from previous_response
-    # Use as pageToken in previous_request to create new request.
-
-    if 'nextPageToken' not in previous_response:
-      return None
-
-    request = copy.copy(previous_request)
-
-    pageToken = previous_response['nextPageToken']
-    parsed = list(urlparse.urlparse(request.uri))
-    q = parse_qsl(parsed[4])
-
-    # Find and remove old 'pageToken' value from URI
-    newq = [(key, value) for (key, value) in q if key != 'pageToken']
-    newq.append(('pageToken', pageToken))
-    parsed[4] = urllib.urlencode(newq)
-    uri = urlparse.urlunparse(parsed)
-
-    request.uri = uri
-
-    logger.info('URL being requested: %s' % uri)
-
-    return request
-
-  return (methodName, methodNext)
-
-
-class Resource(object):
-  """A class for interacting with a resource."""
-
-  def __init__(self, http, baseUrl, model, requestBuilder, developerKey,
-               resourceDesc, rootDesc, schema):
-    """Build a Resource from the API description.
-
-    Args:
-      http: httplib2.Http, Object to make http requests with.
-      baseUrl: string, base URL for the API. All requests are relative to this
-          URI.
-      model: apiclient.Model, converts to and from the wire format.
-      requestBuilder: class or callable that instantiates an
-          apiclient.HttpRequest object.
-      developerKey: string, key obtained from
-          https://code.google.com/apis/console
-      resourceDesc: object, section of deserialized discovery document that
-          describes a resource. Note that the top level discovery document
-          is considered a resource.
-      rootDesc: object, the entire deserialized discovery document.
-      schema: object, mapping of schema names to schema descriptions.
-    """
-    self._dynamic_attrs = []
-
-    self._http = http
-    self._baseUrl = baseUrl
-    self._model = model
-    self._developerKey = developerKey
-    self._requestBuilder = requestBuilder
-    self._resourceDesc = resourceDesc
-    self._rootDesc = rootDesc
-    self._schema = schema
-
-    self._set_service_methods()
-
-  def _set_dynamic_attr(self, attr_name, value):
-    """Sets an instance attribute and tracks it in a list of dynamic attributes.
-
-    Args:
-      attr_name: string; The name of the attribute to be set
-      value: The value being set on the object and tracked in the dynamic cache.
-    """
-    self._dynamic_attrs.append(attr_name)
-    self.__dict__[attr_name] = value
-
-  def __getstate__(self):
-    """Trim the state down to something that can be pickled.
-
-    Uses the fact that the instance variable _dynamic_attrs holds attrs that
-    will be wiped and restored on pickle serialization.
-    """
-    state_dict = copy.copy(self.__dict__)
-    for dynamic_attr in self._dynamic_attrs:
-      del state_dict[dynamic_attr]
-    del state_dict['_dynamic_attrs']
-    return state_dict
-
-  def __setstate__(self, state):
-    """Reconstitute the state of the object from being pickled.
-
-    Uses the fact that the instance variable _dynamic_attrs holds attrs that
-    will be wiped and restored on pickle serialization.
-    """
-    self.__dict__.update(state)
-    self._dynamic_attrs = []
-    self._set_service_methods()
-
-  def _set_service_methods(self):
-    self._add_basic_methods(self._resourceDesc, self._rootDesc, self._schema)
-    self._add_nested_resources(self._resourceDesc, self._rootDesc, self._schema)
-    self._add_next_methods(self._resourceDesc, self._schema)
-
-  def _add_basic_methods(self, resourceDesc, rootDesc, schema):
-    # Add basic methods to Resource
-    if 'methods' in resourceDesc:
-      for methodName, methodDesc in resourceDesc['methods'].iteritems():
-        fixedMethodName, method = createMethod(
-            methodName, methodDesc, rootDesc, schema)
-        self._set_dynamic_attr(fixedMethodName,
-                               method.__get__(self, self.__class__))
-        # Add in _media methods. The functionality of the attached method will
-        # change when it sees that the method name ends in _media.
-        if methodDesc.get('supportsMediaDownload', False):
-          fixedMethodName, method = createMethod(
-              methodName + '_media', methodDesc, rootDesc, schema)
-          self._set_dynamic_attr(fixedMethodName,
-                                 method.__get__(self, self.__class__))
-
-  def _add_nested_resources(self, resourceDesc, rootDesc, schema):
-    # Add in nested resources
-    if 'resources' in resourceDesc:
-
-      def createResourceMethod(methodName, methodDesc):
-        """Create a method on the Resource to access a nested Resource.
-
-        Args:
-          methodName: string, name of the method to use.
-          methodDesc: object, fragment of deserialized discovery document that
-            describes the method.
-        """
-        methodName = fix_method_name(methodName)
-
-        def methodResource(self):
-          return Resource(http=self._http, baseUrl=self._baseUrl,
-                          model=self._model, developerKey=self._developerKey,
-                          requestBuilder=self._requestBuilder,
-                          resourceDesc=methodDesc, rootDesc=rootDesc,
-                          schema=schema)
-
-        setattr(methodResource, '__doc__', 'A collection resource.')
-        setattr(methodResource, '__is_resource__', True)
-
-        return (methodName, methodResource)
-
-      for methodName, methodDesc in resourceDesc['resources'].iteritems():
-        fixedMethodName, method = createResourceMethod(methodName, methodDesc)
-        self._set_dynamic_attr(fixedMethodName,
-                               method.__get__(self, self.__class__))
-
-  def _add_next_methods(self, resourceDesc, schema):
-    # Add _next() methods
-    # Look for response bodies in schema that contain nextPageToken, and methods
-    # that take a pageToken parameter.
-    if 'methods' in resourceDesc:
-      for methodName, methodDesc in resourceDesc['methods'].iteritems():
-        if 'response' in methodDesc:
-          responseSchema = methodDesc['response']
-          if '$ref' in responseSchema:
-            responseSchema = schema.get(responseSchema['$ref'])
-          hasNextPageToken = 'nextPageToken' in responseSchema.get('properties',
-                                                                   {})
-          hasPageToken = 'pageToken' in methodDesc.get('parameters', {})
-          if hasNextPageToken and hasPageToken:
-            fixedMethodName, method = createNextMethod(methodName + '_next')
-            self._set_dynamic_attr(fixedMethodName,
-                                   method.__get__(self, self.__class__))

apiclient/errors.py

@@ -1,140 +0,0 @@
-#!/usr/bin/python2.4
-#
-# Copyright (C) 2010 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Errors for the library.
-
-All exceptions defined by the library
-should be defined in this file.
-"""
-
-__author__ = 'jcgregorio@google.com (Joe Gregorio)'
-
-
-from oauth2client import util
-from oauth2client.anyjson import simplejson
-
-
-class Error(Exception):
-  """Base error for this module."""
-  pass
-
-
-class HttpError(Error):
-  """HTTP data was invalid or unexpected."""
-
-  @util.positional(3)
-  def __init__(self, resp, content, uri=None):
-    self.resp = resp
-    self.content = content
-    self.uri = uri
-
-  def _get_reason(self):
-    """Calculate the reason for the error from the response content."""
-    reason = self.resp.reason
-    try:
-      data = simplejson.loads(self.content)
-      reason = data['error']['message']
-    except (ValueError, KeyError):
-      pass
-    if reason is None:
-      reason = ''
-    return reason
-
-  def __repr__(self):
-    if self.uri:
-      return '<HttpError %s when requesting %s returned "%s">' % (
-          self.resp.status, self.uri, self._get_reason().strip())
-    else:
-      return '<HttpError %s "%s">' % (self.resp.status, self._get_reason())
-
-  __str__ = __repr__
-
-
-class InvalidJsonError(Error):
-  """The JSON returned could not be parsed."""
-  pass
-
-
-class UnknownFileType(Error):
-  """File type unknown or unexpected."""
-  pass
-
-
-class UnknownLinkType(Error):
-  """Link type unknown or unexpected."""
-  pass
-
-
-class UnknownApiNameOrVersion(Error):
-  """No API with that name and version exists."""
-  pass
-
-
-class UnacceptableMimeTypeError(Error):
-  """That is an unacceptable mimetype for this operation."""
-  pass
-
-
-class MediaUploadSizeError(Error):
-  """Media is larger than the method can accept."""
-  pass
-
-
-class ResumableUploadError(HttpError):
-  """Error occured during resumable upload."""
-  pass
-
-
-class InvalidChunkSizeError(Error):
-  """The given chunksize is not valid."""
-  pass
-
-class InvalidNotificationError(Error):
-  """The channel Notification is invalid."""
-  pass
-
-class BatchError(HttpError):
-  """Error occured during batch operations."""
-
-  @util.positional(2)
-  def __init__(self, reason, resp=None, content=None):
-    self.resp = resp
-    self.content = content
-    self.reason = reason
-
-  def __repr__(self):
-      return '<BatchError %s "%s">' % (self.resp.status, self.reason)
-
-  __str__ = __repr__
-
-
-class UnexpectedMethodError(Error):
-  """Exception raised by RequestMockBuilder on unexpected calls."""
-
-  @util.positional(1)
-  def __init__(self, methodId=None):
-    """Constructor for an UnexpectedMethodError."""
-    super(UnexpectedMethodError, self).__init__(
-        'Received unexpected call %s' % methodId)
-
-
-class UnexpectedBodyError(Error):
-  """Exception raised by RequestMockBuilder on unexpected bodies."""
-
-  def __init__(self, expected, provided):
-    """Constructor for an UnexpectedMethodError."""
-    super(UnexpectedBodyError, self).__init__(
-        'Expected: [%s] - Provided: [%s]' % (expected, provided))

apiclient/mimeparse.py

@@ -1,172 +0,0 @@
-# Copyright (C) 2007 Joe Gregorio
-#
-# Licensed under the MIT License
-
-"""MIME-Type Parser
-
-This module provides basic functions for handling mime-types. It can handle
-matching mime-types against a list of media-ranges. See section 14.1 of the
-HTTP specification [RFC 2616] for a complete explanation.
-
-   http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1
-
-Contents:
- - parse_mime_type():   Parses a mime-type into its component parts.
- - parse_media_range(): Media-ranges are mime-types with wild-cards and a 'q'
-                          quality parameter.
- - quality():           Determines the quality ('q') of a mime-type when
-                          compared against a list of media-ranges.
- - quality_parsed():    Just like quality() except the second parameter must be
-                          pre-parsed.
- - best_match():        Choose the mime-type with the highest quality ('q')
-                          from a list of candidates.
-"""
-
-__version__ = '0.1.3'
-__author__ = 'Joe Gregorio'
-__email__ = 'joe@bitworking.org'
-__license__ = 'MIT License'
-__credits__ = ''
-
-
-def parse_mime_type(mime_type):
-    """Parses a mime-type into its component parts.
-
-    Carves up a mime-type and returns a tuple of the (type, subtype, params)
-    where 'params' is a dictionary of all the parameters for the media range.
-    For example, the media range 'application/xhtml;q=0.5' would get parsed
-    into:
-
-       ('application', 'xhtml', {'q', '0.5'})
-       """
-    parts = mime_type.split(';')
-    params = dict([tuple([s.strip() for s in param.split('=', 1)])\
-            for param in parts[1:]
-                  ])
-    full_type = parts[0].strip()
-    # Java URLConnection class sends an Accept header that includes a
-    # single '*'. Turn it into a legal wildcard.
-    if full_type == '*':
-        full_type = '*/*'
-    (type, subtype) = full_type.split('/')
-
-    return (type.strip(), subtype.strip(), params)
-
-
-def parse_media_range(range):
-    """Parse a media-range into its component parts.
-
-    Carves up a media range and returns a tuple of the (type, subtype,
-    params) where 'params' is a dictionary of all the parameters for the media
-    range.  For example, the media range 'application/*;q=0.5' would get parsed
-    into:
-
-       ('application', '*', {'q', '0.5'})
-
-    In addition this function also guarantees that there is a value for 'q'
-    in the params dictionary, filling it in with a proper default if
-    necessary.
-    """
-    (type, subtype, params) = parse_mime_type(range)
-    if not params.has_key('q') or not params['q'] or \
-            not float(params['q']) or float(params['q']) > 1\
-            or float(params['q']) < 0:
-        params['q'] = '1'
-
-    return (type, subtype, params)
-
-
-def fitness_and_quality_parsed(mime_type, parsed_ranges):
-    """Find the best match for a mime-type amongst parsed media-ranges.
-
-    Find the best match for a given mime-type against a list of media_ranges
-    that have already been parsed by parse_media_range(). Returns a tuple of
-    the fitness value and the value of the 'q' quality parameter of the best
-    match, or (-1, 0) if no match was found. Just as for quality_parsed(),
-    'parsed_ranges' must be a list of parsed media ranges.
-    """
-    best_fitness = -1
-    best_fit_q = 0
-    (target_type, target_subtype, target_params) =\
-            parse_media_range(mime_type)
-    for (type, subtype, params) in parsed_ranges:
-        type_match = (type == target_type or\
-                      type == '*' or\
-                      target_type == '*')
-        subtype_match = (subtype == target_subtype or\
-                         subtype == '*' or\
-                         target_subtype == '*')
-        if type_match and subtype_match:
-            param_matches = reduce(lambda x, y: x + y, [1 for (key, value) in \
-                    target_params.iteritems() if key != 'q' and \
-                    params.has_key(key) and value == params[key]], 0)
-            fitness = (type == target_type) and 100 or 0
-            fitness += (subtype == target_subtype) and 10 or 0
-            fitness += param_matches
-            if fitness > best_fitness:
-                best_fitness = fitness
-                best_fit_q = params['q']
-
-    return best_fitness, float(best_fit_q)
-
-
-def quality_parsed(mime_type, parsed_ranges):
-    """Find the best match for a mime-type amongst parsed media-ranges.
-
-    Find the best match for a given mime-type against a list of media_ranges
-    that have already been parsed by parse_media_range(). Returns the 'q'
-    quality parameter of the best match, 0 if no match was found. This function
-    bahaves the same as quality() except that 'parsed_ranges' must be a list of
-    parsed media ranges.
-    """
-
-    return fitness_and_quality_parsed(mime_type, parsed_ranges)[1]
-
-
-def quality(mime_type, ranges):
-    """Return the quality ('q') of a mime-type against a list of media-ranges.
-
-    Returns the quality 'q' of a mime-type when compared against the
-    media-ranges in ranges. For example:
-
-    >>> quality('text/html','text/*;q=0.3, text/html;q=0.7,
-                  text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5')
-    0.7
-
-    """
-    parsed_ranges = [parse_media_range(r) for r in ranges.split(',')]
-
-    return quality_parsed(mime_type, parsed_ranges)
-
-
-def best_match(supported, header):
-    """Return mime-type with the highest quality ('q') from list of candidates.
-
-    Takes a list of supported mime-types and finds the best match for all the
-    media-ranges listed in header. The value of header must be a string that
-    conforms to the format of the HTTP Accept: header. The value of 'supported'
-    is a list of mime-types. The list of supported mime-types should be sorted
-    in order of increasing desirability, in case of a situation where there is
-    a tie.
-
-    >>> best_match(['application/xbel+xml', 'text/xml'],
-                   'text/*;q=0.5,*/*; q=0.1')
-    'text/xml'
-    """
-    split_header = _filter_blank(header.split(','))
-    parsed_header = [parse_media_range(r) for r in split_header]
-    weighted_matches = []
-    pos = 0
-    for mime_type in supported:
-        weighted_matches.append((fitness_and_quality_parsed(mime_type,
-                                 parsed_header), pos, mime_type))
-        pos += 1
-    weighted_matches.sort()
-
-    return weighted_matches[-1][0][1] and weighted_matches[-1][2] or ''
-
-
-def _filter_blank(i):
-    for s in i:
-        if s.strip():
-            yield s

apiclient/model.py

@@ -1,383 +0,0 @@
-#!/usr/bin/python2.4
-#
-# Copyright (C) 2010 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Model objects for requests and responses.
-
-Each API may support one or more serializations, such
-as JSON, Atom, etc. The model classes are responsible
-for converting between the wire format and the Python
-object representation.
-"""
-
-__author__ = 'jcgregorio@google.com (Joe Gregorio)'
-
-import logging
-import urllib
-
-from apiclient import __version__
-from errors import HttpError
-from oauth2client.anyjson import simplejson
-
-
-dump_request_response = False
-
-
-def _abstract():
-  raise NotImplementedError('You need to override this function')
-
-
-class Model(object):
-  """Model base class.
-
-  All Model classes should implement this interface.
-  The Model serializes and de-serializes between a wire
-  format such as JSON and a Python object representation.
-  """
-
-  def request(self, headers, path_params, query_params, body_value):
-    """Updates outgoing requests with a serialized body.
-
-    Args:
-      headers: dict, request headers
-      path_params: dict, parameters that appear in the request path
-      query_params: dict, parameters that appear in the query
-      body_value: object, the request body as a Python object, which must be
-                  serializable.
-    Returns:
-      A tuple of (headers, path_params, query, body)
-
-      headers: dict, request headers
-      path_params: dict, parameters that appear in the request path
-      query: string, query part of the request URI
-      body: string, the body serialized in the desired wire format.
-    """
-    _abstract()
-
-  def response(self, resp, content):
-    """Convert the response wire format into a Python object.
-
-    Args:
-      resp: httplib2.Response, the HTTP response headers and status
-      content: string, the body of the HTTP response
-
-    Returns:
-      The body de-serialized as a Python object.
-
-    Raises:
-      apiclient.errors.HttpError if a non 2xx response is received.
-    """
-    _abstract()
-
-
-class BaseModel(Model):
-  """Base model class.
-
-  Subclasses should provide implementations for the "serialize" and
-  "deserialize" methods, as well as values for the following class attributes.
-
-  Attributes:
-    accept: The value to use for the HTTP Accept header.
-    content_type: The value to use for the HTTP Content-type header.
-    no_content_response: The value to return when deserializing a 204 "No
-        Content" response.
-    alt_param: The value to supply as the "alt" query parameter for requests.
-  """
-
-  accept = None
-  content_type = None
-  no_content_response = None
-  alt_param = None
-
-  def _log_request(self, headers, path_params, query, body):
-    """Logs debugging information about the request if requested."""
-    if dump_request_response:
-      logging.info('--request-start--')
-      logging.info('-headers-start-')
-      for h, v in headers.iteritems():
-        logging.info('%s: %s', h, v)
-      logging.info('-headers-end-')
-      logging.info('-path-parameters-start-')
-      for h, v in path_params.iteritems():
-        logging.info('%s: %s', h, v)
-      logging.info('-path-parameters-end-')
-      logging.info('body: %s', body)
-      logging.info('query: %s', query)
-      logging.info('--request-end--')
-
-  def request(self, headers, path_params, query_params, body_value):
-    """Updates outgoing requests with a serialized body.
-
-    Args:
-      headers: dict, request headers
-      path_params: dict, parameters that appear in the request path
-      query_params: dict, parameters that appear in the query
-      body_value: object, the request body as a Python object, which must be
-                  serializable by simplejson.
-    Returns:
-      A tuple of (headers, path_params, query, body)
-
-      headers: dict, request headers
-      path_params: dict, parameters that appear in the request path
-      query: string, query part of the request URI
-      body: string, the body serialized as JSON
-    """
-    query = self._build_query(query_params)
-    headers['accept'] = self.accept
-    headers['accept-encoding'] = 'gzip, deflate'
-    if 'user-agent' in headers:
-      headers['user-agent'] += ' '
-    else:
-      headers['user-agent'] = ''
-    headers['user-agent'] += 'google-api-python-client/%s (gzip)' % __version__
-
-    if body_value is not None:
-      headers['content-type'] = self.content_type
-      body_value = self.serialize(body_value)
-    self._log_request(headers, path_params, query, body_value)
-    return (headers, path_params, query, body_value)
-
-  def _build_query(self, params):
-    """Builds a query string.
-
-    Args:
-      params: dict, the query parameters
-
-    Returns:
-      The query parameters properly encoded into an HTTP URI query string.
-    """
-    if self.alt_param is not None:
-      params.update({'alt': self.alt_param})
-    astuples = []
-    for key, value in params.iteritems():
-      if type(value) == type([]):
-        for x in value:
-          x = x.encode('utf-8')
-          astuples.append((key, x))
-      else:
-        if getattr(value, 'encode', False) and callable(value.encode):
-          value = value.encode('utf-8')
-        astuples.append((key, value))
-    return '?' + urllib.urlencode(astuples)
-
-  def _log_response(self, resp, content):
-    """Logs debugging information about the response if requested."""
-    if dump_request_response:
-      logging.info('--response-start--')
-      for h, v in resp.iteritems():
-        logging.info('%s: %s', h, v)
-      if content:
-        logging.info(content)
-      logging.info('--response-end--')
-
-  def response(self, resp, content):
-    """Convert the response wire format into a Python object.
-
-    Args:
-      resp: httplib2.Response, the HTTP response headers and status
-      content: string, the body of the HTTP response
-
-    Returns:
-      The body de-serialized as a Python object.
-
-    Raises:
-      apiclient.errors.HttpError if a non 2xx response is received.
-    """
-    self._log_response(resp, content)
-    # Error handling is TBD, for example, do we retry
-    # for some operation/error combinations?
-    if resp.status < 300:
-      if resp.status == 204:
-        # A 204: No Content response should be treated differently
-        # to all the other success states
-        return self.no_content_response
-      return self.deserialize(content)
-    else:
-      logging.debug('Content from bad request was: %s' % content)
-      raise HttpError(resp, content)
-
-  def serialize(self, body_value):
-    """Perform the actual Python object serialization.
-
-    Args:
-      body_value: object, the request body as a Python object.
-
-    Returns:
-      string, the body in serialized form.
-    """
-    _abstract()
-
-  def deserialize(self, content):
-    """Perform the actual deserialization from response string to Python
-    object.
-
-    Args:
-      content: string, the body of the HTTP response
-
-    Returns:
-      The body de-serialized as a Python object.
-    """
-    _abstract()
-
-
-class JsonModel(BaseModel):
-  """Model class for JSON.
-
-  Serializes and de-serializes between JSON and the Python
-  object representation of HTTP request and response bodies.
-  """
-  accept = 'application/json'
-  content_type = 'application/json'
-  alt_param = 'json'
-
-  def __init__(self, data_wrapper=False):
-    """Construct a JsonModel.
-
-    Args:
-      data_wrapper: boolean, wrap requests and responses in a data wrapper
-    """
-    self._data_wrapper = data_wrapper
-
-  def serialize(self, body_value):
-    if (isinstance(body_value, dict) and 'data' not in body_value and
-        self._data_wrapper):
-      body_value = {'data': body_value}
-    return simplejson.dumps(body_value)
-
-  def deserialize(self, content):
-    content = content.decode('utf-8')
-    body = simplejson.loads(content)
-    if self._data_wrapper and isinstance(body, dict) and 'data' in body:
-      body = body['data']
-    return body
-
-  @property
-  def no_content_response(self):
-    return {}
-
-
-class RawModel(JsonModel):
-  """Model class for requests that don't return JSON.
-
-  Serializes and de-serializes between JSON and the Python
-  object representation of HTTP request, and returns the raw bytes
-  of the response body.
-  """
-  accept = '*/*'
-  content_type = 'application/json'
-  alt_param = None
-
-  def deserialize(self, content):
-    return content
-
-  @property
-  def no_content_response(self):
-    return ''
-
-
-class MediaModel(JsonModel):
-  """Model class for requests that return Media.
-
-  Serializes and de-serializes between JSON and the Python
-  object representation of HTTP request, and returns the raw bytes
-  of the response body.
-  """
-  accept = '*/*'
-  content_type = 'application/json'
-  alt_param = 'media'
-
-  def deserialize(self, content):
-    return content
-
-  @property
-  def no_content_response(self):
-    return ''
-
-
-class ProtocolBufferModel(BaseModel):
-  """Model class for protocol buffers.
-
-  Serializes and de-serializes the binary protocol buffer sent in the HTTP
-  request and response bodies.
-  """
-  accept = 'application/x-protobuf'
-  content_type = 'application/x-protobuf'
-  alt_param = 'proto'
-
-  def __init__(self, protocol_buffer):
-    """Constructs a ProtocolBufferModel.
-
-    The serialzed protocol buffer returned in an HTTP response will be
-    de-serialized using the given protocol buffer class.
-
-    Args:
-      protocol_buffer: The protocol buffer class used to de-serialize a
-      response from the API.
-    """
-    self._protocol_buffer = protocol_buffer
-
-  def serialize(self, body_value):
-    return body_value.SerializeToString()
-
-  def deserialize(self, content):
-    return self._protocol_buffer.FromString(content)
-
-  @property
-  def no_content_response(self):
-    return self._protocol_buffer()
-
-
-def makepatch(original, modified):
-  """Create a patch object.
-
-  Some methods support PATCH, an efficient way to send updates to a resource.
-  This method allows the easy construction of patch bodies by looking at the
-  differences between a resource before and after it was modified.
-
-  Args:
-    original: object, the original deserialized resource
-    modified: object, the modified deserialized resource
-  Returns:
-    An object that contains only the changes from original to modified, in a
-    form suitable to pass to a PATCH method.
-
-  Example usage:
-    item = service.activities().get(postid=postid, userid=userid).execute()
-    original = copy.deepcopy(item)
-    item['object']['content'] = 'This is updated.'
-    service.activities.patch(postid=postid, userid=userid,
-      body=makepatch(original, item)).execute()
-  """
-  patch = {}
-  for key, original_value in original.iteritems():
-    modified_value = modified.get(key, None)
-    if modified_value is None:
-      # Use None to signal that the element is deleted
-      patch[key] = None
-    elif original_value != modified_value:
-      if type(original_value) == type({}):
-        # Recursively descend objects
-        patch[key] = makepatch(original_value, modified_value)
-      else:
-        # In the case of simple types or arrays we just replace
-        patch[key] = modified_value
-    else:
-      # Don't add anything to patch if there's no change
-      pass
-  for key in modified:
-    if key not in original:
-      patch[key] = modified[key]
-
-  return patch

apiclient/push.py

@@ -1,274 +0,0 @@
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Push notifications support.
-
-This code is based on experimental APIs and is subject to change.
-"""
-
-__author__ = 'afshar@google.com (Ali Afshar)'
-
-import binascii
-import collections
-import os
-import urllib
-
-SUBSCRIBE = 'X-GOOG-SUBSCRIBE'
-SUBSCRIPTION_ID = 'X-GOOG-SUBSCRIPTION-ID'
-TOPIC_ID = 'X-GOOG-TOPIC-ID'
-TOPIC_URI = 'X-GOOG-TOPIC-URI'
-CLIENT_TOKEN = 'X-GOOG-CLIENT-TOKEN'
-EVENT_TYPE = 'X-GOOG-EVENT-TYPE'
-UNSUBSCRIBE = 'X-GOOG-UNSUBSCRIBE'
-
-
-class InvalidSubscriptionRequestError(ValueError):
-  """The request cannot be subscribed."""
-
-
-def new_token():
-  """Gets a random token for use as a client_token in push notifications.
-
-  Returns:
-    str, a new random token.
-  """
-  return binascii.hexlify(os.urandom(32))
-
-
-class Channel(object):
-  """Base class for channel types."""
-
-  def __init__(self, channel_type, channel_args):
-    """Create a new Channel.
-
-    You probably won't need to create this channel manually, since there are
-    subclassed Channel for each specific type with a more customized set of
-    arguments to pass. However, you may wish to just create it manually here.
-
-    Args:
-      channel_type: str, the type of channel.
-      channel_args: dict, arguments to pass to the channel.
-    """
-    self.channel_type = channel_type
-    self.channel_args = channel_args
-
-  def as_header_value(self):
-    """Create the appropriate header for this channel.
-
-    Returns:
-      str encoded channel description suitable for use as a header.
-    """
-    return '%s?%s' % (self.channel_type, urllib.urlencode(self.channel_args))
-
-  def write_header(self, headers):
-    """Write the appropriate subscribe header to a headers dict.
-
-    Args:
-      headers: dict, headers to add subscribe header to.
-    """
-    headers[SUBSCRIBE] = self.as_header_value()
-
-
-class WebhookChannel(Channel):
-  """Channel for registering web hook notifications."""
-
-  def __init__(self, url, app_engine=False):
-    """Create a new WebhookChannel
-
-    Args:
-      url: str, URL to post notifications to.
-      app_engine: bool, default=False, whether the destination for the
-      notifications is an App Engine application.
-    """
-    super(WebhookChannel, self).__init__(
-        channel_type='web_hook',
-        channel_args={
-            'url': url,
-            'app_engine': app_engine and 'true' or 'false',
-        }
-    )
-
-
-class Headers(collections.defaultdict):
-  """Headers for managing subscriptions."""
-
-
-  ALL_HEADERS = set([SUBSCRIBE, SUBSCRIPTION_ID, TOPIC_ID, TOPIC_URI,
-                     CLIENT_TOKEN, EVENT_TYPE, UNSUBSCRIBE])
-
-  def __init__(self):
-    """Create a new subscription configuration instance."""
-    collections.defaultdict.__init__(self, str)
-
-  def __setitem__(self, key, value):
-    """Set a header value, ensuring the key is an allowed value.
-
-    Args:
-      key: str, the header key.
-      value: str, the header value.
-    Raises:
-      ValueError if key is not one of the accepted headers.
-    """
-    normal_key = self._normalize_key(key)
-    if normal_key not in self.ALL_HEADERS:
-      raise ValueError('Header name must be one of %s.' % self.ALL_HEADERS)
-    else:
-      return collections.defaultdict.__setitem__(self, normal_key, value)
-
-  def __getitem__(self, key):
-    """Get a header value, normalizing the key case.
-
-    Args:
-      key: str, the header key.
-    Returns:
-      String header value.
-    Raises:
-      KeyError if the key is not one of the accepted headers.
-    """
-    normal_key = self._normalize_key(key)
-    if normal_key not in self.ALL_HEADERS:
-      raise ValueError('Header name must be one of %s.' % self.ALL_HEADERS)
-    else:
-      return collections.defaultdict.__getitem__(self, normal_key)
-
-  def _normalize_key(self, key):
-    """Normalize a header name for use as a key."""
-    return key.upper()
-
-  def items(self):
-    """Generator for each header."""
-    for header in self.ALL_HEADERS:
-      value = self[header]
-      if value:
-        yield header, value
-
-  def write(self, headers):
-    """Applies the subscription headers.
-
-    Args:
-      headers: dict of headers to insert values into.
-    """
-    for header, value in self.items():
-      headers[header.lower()] = value
-
-  def read(self, headers):
-    """Read from headers.
-
-    Args:
-      headers: dict of headers to read from.
-    """
-    for header in self.ALL_HEADERS:
-      if header.lower() in headers:
-        self[header] = headers[header.lower()]
-
-
-class Subscription(object):
-  """Information about a subscription."""
-
-  def __init__(self):
-    """Create a new Subscription."""
-    self.headers = Headers()
-
-  @classmethod
-  def for_request(cls, request, channel, client_token=None):
-    """Creates a subscription and attaches it to a request.
-
-    Args:
-      request: An http.HttpRequest to modify for making a subscription.
-      channel: A apiclient.push.Channel describing the subscription to
-               create.
-      client_token: (optional) client token to verify the notification.
-
-    Returns:
-      New subscription object.
-    """
-    subscription = cls.for_channel(channel=channel, client_token=client_token)
-    subscription.headers.write(request.headers)
-    if request.method != 'GET':
-      raise InvalidSubscriptionRequestError(
-          'Can only subscribe to requests which are GET.')
-    request.method = 'POST'
-
-    def _on_response(response, subscription=subscription):
-      """Called with the response headers. Reads the subscription headers."""
-      subscription.headers.read(response)
-
-    request.add_response_callback(_on_response)
-    return subscription
-
-  @classmethod
-  def for_channel(cls, channel, client_token=None):
-    """Alternate constructor to create a subscription from a channel.
-
-    Args:
-      channel: A apiclient.push.Channel describing the subscription to
-               create.
-      client_token: (optional) client token to verify the notification.
-
-    Returns:
-      New subscription object.
-    """
-    subscription = cls()
-    channel.write_header(subscription.headers)
-    if client_token is None:
-      client_token = new_token()
-    subscription.headers[SUBSCRIPTION_ID] = new_token()
-    subscription.headers[CLIENT_TOKEN] = client_token
-    return subscription
-
-  def verify(self, headers):
-    """Verifies that a webhook notification has the correct client_token.
-
-    Args:
-      headers: dict of request headers for a push notification.
-
-    Returns:
-      Boolean value indicating whether the notification is verified.
-    """
-    new_subscription = Subscription()
-    new_subscription.headers.read(headers)
-    return new_subscription.client_token == self.client_token
-
-  @property
-  def subscribe(self):
-    """Subscribe header value."""
-    return self.headers[SUBSCRIBE]
-
-  @property
-  def subscription_id(self):
-    """Subscription ID header value."""
-    return self.headers[SUBSCRIPTION_ID]
-
-  @property
-  def topic_id(self):
-    """Topic ID header value."""
-    return self.headers[TOPIC_ID]
-
-  @property
-  def topic_uri(self):
-    """Topic URI header value."""
-    return self.headers[TOPIC_URI]
-
-  @property
-  def client_token(self):
-    """Client Token header value."""
-    return self.headers[CLIENT_TOKEN]
-
-  @property
-  def event_type(self):
-    """Event Type header value."""
-    return self.headers[EVENT_TYPE]
-
-  @property
-  def unsubscribe(self):
-    """Unsuscribe header value."""
-    return self.headers[UNSUBSCRIBE]

apiclient/sample_tools.py

@@ -1,93 +0,0 @@
-# Copyright (C) 2013 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Utilities for making samples.
-
-Consolidates a lot of code commonly repeated in sample applications.
-"""
-
-__author__ = 'jcgregorio@google.com (Joe Gregorio)'
-__all__ = ['init']
-
-
-import argparse
-import httplib2
-import os
-
-from apiclient import discovery
-from oauth2client import client
-from oauth2client import file
-from oauth2client import tools
-
-
-def init(argv, name, version, doc, filename, scope=None, parents=[]):
-  """A common initialization routine for samples.
-
-  Many of the sample applications do the same initialization, which has now
-  been consolidated into this function. This function uses common idioms found
-  in almost all the samples, i.e. for an API with name 'apiname', the
-  credentials are stored in a file named apiname.dat, and the
-  client_secrets.json file is stored in the same directory as the application
-  main file.
-
-  Args:
-    argv: list of string, the command-line parameters of the application.
-    name: string, name of the API.
-    version: string, version of the API.
-    doc: string, description of the application. Usually set to __doc__.
-    file: string, filename of the application. Usually set to __file__.
-    parents: list of argparse.ArgumentParser, additional command-line flags.
-    scope: string, The OAuth scope used.
-
-  Returns:
-    A tuple of (service, flags), where service is the service object and flags
-    is the parsed command-line flags.
-  """
-  if scope is None:
-    scope = 'https://www.googleapis.com/auth/' + name
-
-  # Parser command-line arguments.
-  parent_parsers = [tools.argparser]
-  parent_parsers.extend(parents)
-  parser = argparse.ArgumentParser(
-      description=doc,
-      formatter_class=argparse.RawDescriptionHelpFormatter,
-      parents=parent_parsers)
-  flags = parser.parse_args(argv[1:])
-
-  # Name of a file containing the OAuth 2.0 information for this
-  # application, including client_id and client_secret, which are found
-  # on the API Access tab on the Google APIs
-  # Console <http://code.google.com/apis/console>.
-  client_secrets = os.path.join(os.path.dirname(filename),
-                                'client_secrets.json')
-
-  # Set up a Flow object to be used if we need to authenticate.
-  flow = client.flow_from_clientsecrets(client_secrets,
-      scope=scope,
-      message=tools.message_if_missing(client_secrets))
-
-  # Prepare credentials, and authorize HTTP object with them.
-  # If the credentials don't exist or are invalid run through the native client
-  # flow. The Storage object will ensure that if successful the good
-  # credentials will get written back to a file.
-  storage = file.Storage(name + '.dat')
-  credentials = storage.get()
-  if credentials is None or credentials.invalid:
-    credentials = tools.run_flow(flow, storage, flags)
-  http = credentials.authorize(http = httplib2.Http())
-
-  # Construct a service object via the discovery service.
-  service = discovery.build(name, version, http=http)
-  return (service, flags)

apiclient/schema.py

@@ -1,312 +0,0 @@
-# Copyright (C) 2010 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Schema processing for discovery based APIs
-
-Schemas holds an APIs discovery schemas. It can return those schema as
-deserialized JSON objects, or pretty print them as prototype objects that
-conform to the schema.
-
-For example, given the schema:
-
- schema = \"\"\"{
-   "Foo": {
-    "type": "object",
-    "properties": {
-     "etag": {
-      "type": "string",
-      "description": "ETag of the collection."
-     },
-     "kind": {
-      "type": "string",
-      "description": "Type of the collection ('calendar#acl').",
-      "default": "calendar#acl"
-     },
-     "nextPageToken": {
-      "type": "string",
-      "description": "Token used to access the next
-         page of this result. Omitted if no further results are available."
-     }
-    }
-   }
- }\"\"\"
-
- s = Schemas(schema)
- print s.prettyPrintByName('Foo')
-
- Produces the following output:
-
-  {
-   "nextPageToken": "A String", # Token used to access the
-       # next page of this result. Omitted if no further results are available.
-   "kind": "A String", # Type of the collection ('calendar#acl').
-   "etag": "A String", # ETag of the collection.
-  },
-
-The constructor takes a discovery document in which to look up named schema.
-"""
-
-# TODO(jcgregorio) support format, enum, minimum, maximum
-
-__author__ = 'jcgregorio@google.com (Joe Gregorio)'
-
-import copy
-
-from oauth2client import util
-from oauth2client.anyjson import simplejson
-
-
-class Schemas(object):
-  """Schemas for an API."""
-
-  def __init__(self, discovery):
-    """Constructor.
-
-    Args:
-      discovery: object, Deserialized discovery document from which we pull
-        out the named schema.
-    """
-    self.schemas = discovery.get('schemas', {})
-
-    # Cache of pretty printed schemas.
-    self.pretty = {}
-
-  @util.positional(2)
-  def _prettyPrintByName(self, name, seen=None, dent=0):
-    """Get pretty printed object prototype from the schema name.
-
-    Args:
-      name: string, Name of schema in the discovery document.
-      seen: list of string, Names of schema already seen. Used to handle
-        recursive definitions.
-
-    Returns:
-      string, A string that contains a prototype object with
-        comments that conforms to the given schema.
-    """
-    if seen is None:
-      seen = []
-
-    if name in seen:
-      # Do not fall into an infinite loop over recursive definitions.
-      return '# Object with schema name: %s' % name
-    seen.append(name)
-
-    if name not in self.pretty:
-      self.pretty[name] = _SchemaToStruct(self.schemas[name],
-          seen, dent=dent).to_str(self._prettyPrintByName)
-
-    seen.pop()
-
-    return self.pretty[name]
-
-  def prettyPrintByName(self, name):
-    """Get pretty printed object prototype from the schema name.
-
-    Args:
-      name: string, Name of schema in the discovery document.
-
-    Returns:
-      string, A string that contains a prototype object with
-        comments that conforms to the given schema.
-    """
-    # Return with trailing comma and newline removed.
-    return self._prettyPrintByName(name, seen=[], dent=1)[:-2]
-
-  @util.positional(2)
-  def _prettyPrintSchema(self, schema, seen=None, dent=0):
-    """Get pretty printed object prototype of schema.
-
-    Args:
-      schema: object, Parsed JSON schema.
-      seen: list of string, Names of schema already seen. Used to handle
-        recursive definitions.
-
-    Returns:
-      string, A string that contains a prototype object with
-        comments that conforms to the given schema.
-    """
-    if seen is None:
-      seen = []
-
-    return _SchemaToStruct(schema, seen, dent=dent).to_str(self._prettyPrintByName)
-
-  def prettyPrintSchema(self, schema):
-    """Get pretty printed object prototype of schema.
-
-    Args:
-      schema: object, Parsed JSON schema.
-
-    Returns:
-      string, A string that contains a prototype object with
-        comments that conforms to the given schema.
-    """
-    # Return with trailing comma and newline removed.
-    return self._prettyPrintSchema(schema, dent=1)[:-2]
-
-  def get(self, name):
-    """Get deserialized JSON schema from the schema name.
-
-    Args:
-      name: string, Schema name.
-    """
-    return self.schemas[name]
-
-
-class _SchemaToStruct(object):
-  """Convert schema to a prototype object."""
-
-  @util.positional(3)
-  def __init__(self, schema, seen, dent=0):
-    """Constructor.
-
-    Args:
-      schema: object, Parsed JSON schema.
-      seen: list, List of names of schema already seen while parsing. Used to
-        handle recursive definitions.
-      dent: int, Initial indentation depth.
-    """
-    # The result of this parsing kept as list of strings.
-    self.value = []
-
-    # The final value of the parsing.
-    self.string = None
-
-    # The parsed JSON schema.
-    self.schema = schema
-
-    # Indentation level.
-    self.dent = dent
-
-    # Method that when called returns a prototype object for the schema with
-    # the given name.
-    self.from_cache = None
-
-    # List of names of schema already seen while parsing.
-    self.seen = seen
-
-  def emit(self, text):
-    """Add text as a line to the output.
-
-    Args:
-      text: string, Text to output.
-    """
-    self.value.extend(["  " * self.dent, text, '\n'])
-
-  def emitBegin(self, text):
-    """Add text to the output, but with no line terminator.
-
-    Args:
-      text: string, Text to output.
-      """
-    self.value.extend(["  " * self.dent, text])
-
-  def emitEnd(self, text, comment):
-    """Add text and comment to the output with line terminator.
-
-    Args:
-      text: string, Text to output.
-      comment: string, Python comment.
-    """
-    if comment:
-      divider = '\n' + '  ' * (self.dent + 2) + '# '
-      lines = comment.splitlines()
-      lines = [x.rstrip() for x in lines]
-      comment = divider.join(lines)
-      self.value.extend([text, ' # ', comment, '\n'])
-    else:
-      self.value.extend([text, '\n'])
-
-  def indent(self):
-    """Increase indentation level."""
-    self.dent += 1
-
-  def undent(self):
-    """Decrease indentation level."""
-    self.dent -= 1
-
-  def _to_str_impl(self, schema):
-    """Prototype object based on the schema, in Python code with comments.
-
-    Args:
-      schema: object, Parsed JSON schema file.
-
-    Returns:
-      Prototype object based on the schema, in Python code with comments.
-    """
-    stype = schema.get('type')
-    if stype == 'object':
-      self.emitEnd('{', schema.get('description', ''))
-      self.indent()
-      if 'properties' in schema:
-        for pname, pschema in schema.get('properties', {}).iteritems():
-          self.emitBegin('"%s": ' % pname)
-          self._to_str_impl(pschema)
-      elif 'additionalProperties' in schema:
-        self.emitBegin('"a_key": ')
-        self._to_str_impl(schema['additionalProperties'])
-      self.undent()
-      self.emit('},')
-    elif '$ref' in schema:
-      schemaName = schema['$ref']
-      description = schema.get('description', '')
-      s = self.from_cache(schemaName, seen=self.seen)
-      parts = s.splitlines()
-      self.emitEnd(parts[0], description)
-      for line in parts[1:]:
-        self.emit(line.rstrip())
-    elif stype == 'boolean':
-      value = schema.get('default', 'True or False')
-      self.emitEnd('%s,' % str(value), schema.get('description', ''))
-    elif stype == 'string':
-      value = schema.get('default', 'A String')
-      self.emitEnd('"%s",' % str(value), schema.get('description', ''))
-    elif stype == 'integer':
-      value = schema.get('default', '42')
-      self.emitEnd('%s,' % str(value), schema.get('description', ''))
-    elif stype == 'number':
-      value = schema.get('default', '3.14')
-      self.emitEnd('%s,' % str(value), schema.get('description', ''))
-    elif stype == 'null':
-      self.emitEnd('None,', schema.get('description', ''))
-    elif stype == 'any':
-      self.emitEnd('"",', schema.get('description', ''))
-    elif stype == 'array':
-      self.emitEnd('[', schema.get('description'))
-      self.indent()
-      self.emitBegin('')
-      self._to_str_impl(schema['items'])
-      self.undent()
-      self.emit('],')
-    else:
-      self.emit('Unknown type! %s' % stype)
-      self.emitEnd('', '')
-
-    self.string = ''.join(self.value)
-    return self.string
-
-  def to_str(self, from_cache):
-    """Prototype object based on the schema, in Python code with comments.
-
-    Args:
-      from_cache: callable(name, seen), Callable that retrieves an object
-         prototype for a schema with the given name. Seen is a list of schema
-         names already seen as we recursively descend the schema definition.
-
-    Returns:
-      Prototype object based on the schema, in Python code with comments.
-      The lines of the code will all be properly indented.
-    """
-    self.from_cache = from_cache
-    return self._to_str_impl(self.schema)

atom/auth.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python
-#
-#    Copyright (C) 2009 Google Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-
-# This module is used for version 2 of the Google Data APIs.
-
-
-__author__ = 'j.s@google.com (Jeff Scudder)'
-
-
-import base64
-
-
-class BasicAuth(object):
-  """Sets the Authorization header as defined in RFC1945"""
-
-  def __init__(self, user_id, password):
-    self.basic_cookie = base64.encodestring(
-        '%s:%s' % (user_id, password)).strip()
-
-  def modify_request(self, http_request):
-    http_request.headers['Authorization'] = 'Basic %s' % self.basic_cookie
-
-  ModifyRequest = modify_request
-
-
-class NoAuth(object):
-
-  def modify_request(self, http_request):
-    pass

atom/client.py

@@ -1,221 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2009 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""AtomPubClient provides CRUD ops. in line with the Atom Publishing Protocol.
-
-"""
-
-__author__ = 'j.s@google.com (Jeff Scudder)'
-
-
-import atom.http_core
-
-
-class Error(Exception):
-  pass
-
-
-class MissingHost(Error):
-  pass
-
-
-class AtomPubClient(object):
-  host = None
-  auth_token = None
-  ssl = False # Whether to force all requests over https
-  xoauth_requestor_id = None
-
-  def __init__(self, http_client=None, host=None, auth_token=None, source=None,
-               xoauth_requestor_id=None, **kwargs):
-    """Creates a new AtomPubClient instance.
-
-    Args:
-      source: The name of your application.
-      http_client: An object capable of performing HTTP requests through a
-                   request method. This object is used to perform the request
-                   when the AtomPubClient's request method is called. Used to
-                   allow HTTP requests to be directed to a mock server, or use
-                   an alternate library instead of the default of httplib to
-                   make HTTP requests.
-      host: str The default host name to use if a host is not specified in the
-            requested URI.
-      auth_token: An object which sets the HTTP Authorization header when its
-                  modify_request method is called.
-    """
-    self.http_client = http_client or atom.http_core.ProxiedHttpClient()
-    if host is not None:
-      self.host = host
-    if auth_token is not None:
-      self.auth_token = auth_token
-    self.xoauth_requestor_id = xoauth_requestor_id
-    self.source = source
-
-  def request(self, method=None, uri=None, auth_token=None,
-              http_request=None, **kwargs):
-    """Performs an HTTP request to the server indicated.
-
-    Uses the http_client instance to make the request.
-
-    Args:
-      method: The HTTP method as a string, usually one of 'GET', 'POST',
-              'PUT', or 'DELETE'
-      uri: The URI desired as a string or atom.http_core.Uri.
-      http_request:
-      auth_token: An authorization token object whose modify_request method
-                  sets the HTTP Authorization header.
-
-    Returns:
-      The results of calling self.http_client.request. With the default
-      http_client, this is an HTTP response object.
-    """
-    # Modify the request based on the AtomPubClient settings and parameters
-    # passed in to the request.
-    http_request = self.modify_request(http_request)
-    if isinstance(uri, (str, unicode)):
-      uri = atom.http_core.Uri.parse_uri(uri)
-    if uri is not None:
-      uri.modify_request(http_request)
-    if isinstance(method, (str, unicode)):
-      http_request.method = method
-    # Any unrecognized arguments are assumed to be capable of modifying the
-    # HTTP request.
-    for name, value in kwargs.iteritems():
-      if value is not None:
-        value.modify_request(http_request)
-    # Default to an http request if the protocol scheme is not set.
-    if http_request.uri.scheme is None:
-      http_request.uri.scheme = 'http'
-    # Override scheme. Force requests over https.
-    if self.ssl:
-      http_request.uri.scheme = 'https'
-    if http_request.uri.path is None:
-      http_request.uri.path = '/'
-    # Add the Authorization header at the very end. The Authorization header
-    # value may need to be calculated using information in the request.
-    if auth_token:
-      auth_token.modify_request(http_request)
-    elif self.auth_token:
-      self.auth_token.modify_request(http_request)
-    # Check to make sure there is a host in the http_request.
-    if http_request.uri.host is None:
-      raise MissingHost('No host provided in request %s %s' % (
-          http_request.method, str(http_request.uri)))
-    # Perform the fully specified request using the http_client instance.
-    # Sends the request to the server and returns the server's response.
-    return self.http_client.request(http_request)
-
-  Request = request
-
-  def get(self, uri=None, auth_token=None, http_request=None, **kwargs):
-    """Performs a request using the GET method, returns an HTTP response."""
-    return self.request(method='GET', uri=uri, auth_token=auth_token,
-                        http_request=http_request, **kwargs)
-
-  Get = get
-
-  def post(self, uri=None, data=None, auth_token=None, http_request=None,
-           **kwargs):
-    """Sends data using the POST method, returns an HTTP response."""
-    return self.request(method='POST', uri=uri, auth_token=auth_token,
-                        http_request=http_request, data=data, **kwargs)
-
-  Post = post
-
-  def put(self, uri=None, data=None, auth_token=None, http_request=None,
-          **kwargs):
-    """Sends data using the PUT method, returns an HTTP response."""
-    return self.request(method='PUT', uri=uri, auth_token=auth_token,
-                        http_request=http_request, data=data, **kwargs)
-
-  Put = put
-
-  def delete(self, uri=None, auth_token=None, http_request=None, **kwargs):
-    """Performs a request using the DELETE method, returns an HTTP response."""
-    return self.request(method='DELETE', uri=uri, auth_token=auth_token,
-                        http_request=http_request, **kwargs)
-
-  Delete = delete
-
-  def modify_request(self, http_request):
-    """Changes the HTTP request before sending it to the server.
-
-    Sets the User-Agent HTTP header and fills in the HTTP host portion
-    of the URL if one was not included in the request (for this it uses
-    the self.host member if one is set). This method is called in
-    self.request.
-
-    Args:
-      http_request: An atom.http_core.HttpRequest() (optional) If one is
-                    not provided, a new HttpRequest is instantiated.
-
-    Returns:
-      An atom.http_core.HttpRequest() with the User-Agent header set and
-      if this client has a value in its host member, the host in the request
-      URL is set.
-    """
-    if http_request is None:
-      http_request = atom.http_core.HttpRequest()
-
-    if self.host is not None and http_request.uri.host is None:
-      http_request.uri.host = self.host
-
-    if self.xoauth_requestor_id is not None:
-      http_request.uri.query['xoauth_requestor_id'] = self.xoauth_requestor_id
-
-    # Set the user agent header for logging purposes.
-    if self.source:
-      http_request.headers['User-Agent'] = '%s gdata-py/2.0.14' % self.source
-    else:
-      http_request.headers['User-Agent'] = 'gdata-py/2.0.14'
-
-    return http_request
-
-  ModifyRequest = modify_request
-
-
-class CustomHeaders(object):
-  """Add custom headers to an http_request.
-
-  Usage:
-    >>> custom_headers = atom.client.CustomHeaders(header1='value1',
-            header2='value2')
-    >>> client.get(uri, custom_headers=custom_headers)
-  """
-
-  def __init__(self, **kwargs):
-    """Creates a CustomHeaders instance.
-
-    Initialize the headers dictionary with the arguments list.
-    """
-    self.headers = kwargs
-
-  def modify_request(self, http_request):
-    """Changes the HTTP request before sending it to the server.
-
-    Adds the custom headers to the HTTP request.
-
-    Args:
-      http_request: An atom.http_core.HttpRequest().
-
-    Returns:
-      An atom.http_core.HttpRequest() with the added custom headers.
-    """
-
-    for name, value in self.headers.iteritems():
-      if value is not None:
-        http_request.headers[name] = value
-    return http_request

atom/core.py

@@ -1,550 +0,0 @@
-#!/usr/bin/env python
-#
-#    Copyright (C) 2008 Google Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-
-# This module is used for version 2 of the Google Data APIs.
-
-
-__author__ = 'j.s@google.com (Jeff Scudder)'
-
-
-import inspect
-try:
-  from xml.etree import cElementTree as ElementTree
-except ImportError:
-  try:
-    import cElementTree as ElementTree
-  except ImportError:
-    try:
-      from xml.etree import ElementTree
-    except ImportError:
-      from elementtree import ElementTree
-
-
-try:
-    from xml.dom.minidom import parseString as xmlString
-except ImportError:
-    xmlString = None
-
-STRING_ENCODING = 'utf-8'
-
-
-class XmlElement(object):
-  """Represents an element node in an XML document.
-
-  The text member is a UTF-8 encoded str or unicode.
-  """
-  _qname = None
-  _other_elements = None
-  _other_attributes = None
-  # The rule set contains mappings for XML qnames to child members and the
-  # appropriate member classes.
-  _rule_set = None
-  _members = None
-  text = None
-
-  def __init__(self, text=None, *args, **kwargs):
-    if ('_members' not in self.__class__.__dict__
-        or self.__class__._members is None):
-      self.__class__._members = tuple(self.__class__._list_xml_members())
-    for member_name, member_type in self.__class__._members:
-      if member_name in kwargs:
-        setattr(self, member_name, kwargs[member_name])
-      else:
-        if isinstance(member_type, list):
-          setattr(self, member_name, [])
-        else:
-          setattr(self, member_name, None)
-    self._other_elements = []
-    self._other_attributes = {}
-    if text is not None:
-      self.text = text
-
-  def _list_xml_members(cls):
-    """Generator listing all members which are XML elements or attributes.
-
-    The following members would be considered XML members:
-    foo = 'abc' - indicates an XML attribute with the qname abc
-    foo = SomeElement - indicates an XML child element
-    foo = [AnElement] - indicates a repeating XML child element, each instance
-        will be stored in a list in this member
-    foo = ('att1', '{http://example.com/namespace}att2') - indicates an XML
-        attribute which has different parsing rules in different versions of
-        the protocol. Version 1 of the XML parsing rules will look for an
-        attribute with the qname 'att1' but verion 2 of the parsing rules will
-        look for a namespaced attribute with the local name of 'att2' and an
-        XML namespace of 'http://example.com/namespace'.
-    """
-    members = []
-    for pair in inspect.getmembers(cls):
-      if not pair[0].startswith('_') and pair[0] != 'text':
-        member_type = pair[1]
-        if (isinstance(member_type, tuple) or isinstance(member_type, list)
-            or isinstance(member_type, (str, unicode))
-            or (inspect.isclass(member_type)
-                and issubclass(member_type, XmlElement))):
-          members.append(pair)
-    return members
-
-  _list_xml_members = classmethod(_list_xml_members)
-
-  def _get_rules(cls, version):
-    """Initializes the _rule_set for the class which is used when parsing XML.
-
-    This method is used internally for parsing and generating XML for an
-    XmlElement. It is not recommended that you call this method directly.
-
-    Returns:
-      A tuple containing the XML parsing rules for the appropriate version.
-
-      The tuple looks like:
-      (qname, {sub_element_qname: (member_name, member_class, repeating), ..},
-       {attribute_qname: member_name})
-
-      To give a couple of concrete example, the atom.data.Control _get_rules
-      with version of 2 will return:
-      ('{http://www.w3.org/2007/app}control',
-       {'{http://www.w3.org/2007/app}draft': ('draft',
-                                              <class 'atom.data.Draft'>,
-                                              False)},
-       {})
-      Calling _get_rules with version 1 on gdata.data.FeedLink will produce:
-      ('{http://schemas.google.com/g/2005}feedLink',
-       {'{http://www.w3.org/2005/Atom}feed': ('feed',
-                                              <class 'gdata.data.GDFeed'>,
-                                              False)},
-       {'href': 'href', 'readOnly': 'read_only', 'countHint': 'count_hint',
-        'rel': 'rel'})
-    """
-    # Initialize the _rule_set to make sure there is a slot available to store
-    # the parsing rules for this version of the XML schema.
-    # Look for rule set in the class __dict__ proxy so that only the
-    # _rule_set for this class will be found. By using the dict proxy
-    # we avoid finding rule_sets defined in superclasses.
-    # The four lines below provide support for any number of versions, but it
-    # runs a bit slower then hard coding slots for two versions, so I'm using
-    # the below two lines.
-    #if '_rule_set' not in cls.__dict__ or cls._rule_set is None:
-    #  cls._rule_set = []
-    #while len(cls.__dict__['_rule_set']) < version:
-    #  cls._rule_set.append(None)
-    # If there is no rule set cache in the class, provide slots for two XML
-    # versions. If and when there is a version 3, this list will need to be
-    # expanded.
-    if '_rule_set' not in cls.__dict__ or cls._rule_set is None:
-      cls._rule_set = [None, None]
-    # If a version higher than 2 is requested, fall back to version 2 because
-    # 2 is currently the highest supported version.
-    if version > 2:
-      return cls._get_rules(2)
-    # Check the dict proxy for the rule set to avoid finding any rule sets
-    # which belong to the superclass. We only want rule sets for this class.
-    if cls._rule_set[version-1] is None:
-      # The rule set for each version consists of the qname for this element
-      # ('{namespace}tag'), a dictionary (elements) for looking up the
-      # corresponding class member when given a child element's qname, and a
-      # dictionary (attributes) for looking up the corresponding class member
-      # when given an XML attribute's qname.
-      elements = {}
-      attributes = {}
-      if ('_members' not in cls.__dict__ or cls._members is None):
-        cls._members = tuple(cls._list_xml_members())
-      for member_name, target in cls._members:
-        if isinstance(target, list):
-          # This member points to a repeating element.
-          elements[_get_qname(target[0], version)] = (member_name, target[0],
-              True)
-        elif isinstance(target, tuple):
-          # This member points to a versioned XML attribute.
-          if version <= len(target):
-            attributes[target[version-1]] = member_name
-          else:
-            attributes[target[-1]] = member_name
-        elif isinstance(target, (str, unicode)):
-          # This member points to an XML attribute.
-          attributes[target] = member_name
-        elif issubclass(target, XmlElement):
-          # This member points to a single occurance element.
-          elements[_get_qname(target, version)] = (member_name, target, False)
-      version_rules = (_get_qname(cls, version), elements, attributes)
-      cls._rule_set[version-1] = version_rules
-      return version_rules
-    else:
-      return cls._rule_set[version-1]
-
-  _get_rules = classmethod(_get_rules)
-
-  def get_elements(self, tag=None, namespace=None, version=1):
-    """Find all sub elements which match the tag and namespace.
-
-    To find all elements in this object, call get_elements with the tag and
-    namespace both set to None (the default). This method searches through
-    the object's members and the elements stored in _other_elements which
-    did not match any of the XML parsing rules for this class.
-
-    Args:
-      tag: str
-      namespace: str
-      version: int Specifies the version of the XML rules to be used when
-               searching for matching elements.
-
-    Returns:
-      A list of the matching XmlElements.
-    """
-    matches = []
-    ignored1, elements, ignored2 = self.__class__._get_rules(version)
-    if elements:
-      for qname, element_def in elements.iteritems():
-        member = getattr(self, element_def[0])
-        if member:
-          if _qname_matches(tag, namespace, qname):
-            if element_def[2]:
-              # If this is a repeating element, copy all instances into the
-              # result list.
-              matches.extend(member)
-            else:
-              matches.append(member)
-    for element in self._other_elements:
-      if _qname_matches(tag, namespace, element._qname):
-        matches.append(element)
-    return matches
-
-  GetElements = get_elements
-  # FindExtensions and FindChildren are provided for backwards compatibility
-  # to the atom.AtomBase class.
-  # However, FindExtensions may return more results than the v1 atom.AtomBase
-  # method does, because get_elements searches both the expected children
-  # and the unexpected "other elements". The old AtomBase.FindExtensions
-  # method searched only "other elements" AKA extension_elements.
-  FindExtensions = get_elements
-  FindChildren = get_elements
-
-  def get_attributes(self, tag=None, namespace=None, version=1):
-    """Find all attributes which match the tag and namespace.
-
-    To find all attributes in this object, call get_attributes with the tag
-    and namespace both set to None (the default). This method searches
-    through the object's members and the attributes stored in
-    _other_attributes which did not fit any of the XML parsing rules for this
-    class.
-
-    Args:
-      tag: str
-      namespace: str
-      version: int Specifies the version of the XML rules to be used when
-               searching for matching attributes.
-
-    Returns:
-      A list of XmlAttribute objects for the matching attributes.
-    """
-    matches = []
-    ignored1, ignored2, attributes = self.__class__._get_rules(version)
-    if attributes:
-      for qname, attribute_def in attributes.iteritems():
-        if isinstance(attribute_def, (list, tuple)):
-          attribute_def = attribute_def[0]
-        member = getattr(self, attribute_def)
-        # TODO: ensure this hasn't broken existing behavior.
-        #member = getattr(self, attribute_def[0])
-        if member:
-          if _qname_matches(tag, namespace, qname):
-            matches.append(XmlAttribute(qname, member))
-    for qname, value in self._other_attributes.iteritems():
-      if _qname_matches(tag, namespace, qname):
-        matches.append(XmlAttribute(qname, value))
-    return matches
-
-  GetAttributes = get_attributes
-
-  def _harvest_tree(self, tree, version=1):
-    """Populates object members from the data in the tree Element."""
-    qname, elements, attributes = self.__class__._get_rules(version)
-    for element in tree:
-      if elements and element.tag in elements:
-        definition = elements[element.tag]
-        # If this is a repeating element, make sure the member is set to a
-        # list.
-        if definition[2]:
-          if getattr(self, definition[0]) is None:
-            setattr(self, definition[0], [])
-          getattr(self, definition[0]).append(_xml_element_from_tree(element,
-              definition[1], version))
-        else:
-          setattr(self, definition[0], _xml_element_from_tree(element,
-              definition[1], version))
-      else:
-        self._other_elements.append(_xml_element_from_tree(element, XmlElement,
-                                                           version))
-    for attrib, value in tree.attrib.iteritems():
-      if attributes and attrib in attributes:
-        setattr(self, attributes[attrib], value)
-      else:
-        self._other_attributes[attrib] = value
-    if tree.text:
-      self.text = tree.text
-
-  def _to_tree(self, version=1, encoding=None):
-    new_tree = ElementTree.Element(_get_qname(self, version))
-    self._attach_members(new_tree, version, encoding)
-    return new_tree
-
-  def _attach_members(self, tree, version=1, encoding=None):
-    """Convert members to XML elements/attributes and add them to the tree.
-
-    Args:
-      tree: An ElementTree.Element which will be modified. The members of
-            this object will be added as child elements or attributes
-            according to the rules described in _expected_elements and
-            _expected_attributes. The elements and attributes stored in
-            other_attributes and other_elements are also added a children
-            of this tree.
-      version: int Ingnored in this method but used by VersionedElement.
-      encoding: str (optional)
-    """
-    qname, elements, attributes = self.__class__._get_rules(version)
-    encoding = encoding or STRING_ENCODING
-    # Add the expected elements and attributes to the tree.
-    if elements:
-      for tag, element_def in elements.iteritems():
-        member = getattr(self, element_def[0])
-        # If this is a repeating element and there are members in the list.
-        if member and element_def[2]:
-          for instance in member:
-            instance._become_child(tree, version)
-        elif member:
-          member._become_child(tree, version)
-    if attributes:
-      for attribute_tag, member_name in attributes.iteritems():
-        value = getattr(self, member_name)
-        if value:
-          tree.attrib[attribute_tag] = value
-    # Add the unexpected (other) elements and attributes to the tree.
-    for element in self._other_elements:
-      element._become_child(tree, version)
-    for key, value in self._other_attributes.iteritems():
-      # I'm not sure if unicode can be used in the attribute name, so for now
-      # we assume the encoding is correct for the attribute name.
-      if not isinstance(value, unicode):
-        value = value.decode(encoding)
-      tree.attrib[key] = value
-    if self.text:
-      if isinstance(self.text, unicode):
-        tree.text = self.text
-      else:
-        tree.text = self.text.decode(encoding)
-
-  def to_string(self, version=1, encoding=None, pretty_print=None):
-    """Converts this object to XML."""
-
-    tree_string = ElementTree.tostring(self._to_tree(version, encoding))
-
-    if pretty_print and xmlString is not None:
-        return xmlString(tree_string).toprettyxml()
- 
-    return tree_string
- 
-  ToString = to_string
-
-  def __str__(self):
-    return self.to_string()
-
-  def _become_child(self, tree, version=1):
-    """Adds a child element to tree with the XML data in self."""
-    new_child = ElementTree.Element('')
-    tree.append(new_child)
-    new_child.tag = _get_qname(self, version)
-    self._attach_members(new_child, version)
-
-  def __get_extension_elements(self):
-    return self._other_elements
-
-  def __set_extension_elements(self, elements):
-    self._other_elements = elements
-
-  extension_elements = property(__get_extension_elements,
-      __set_extension_elements,
-      """Provides backwards compatibility for v1 atom.AtomBase classes.""")
-
-  def __get_extension_attributes(self):
-    return self._other_attributes
-
-  def __set_extension_attributes(self, attributes):
-    self._other_attributes = attributes
-
-  extension_attributes = property(__get_extension_attributes,
-      __set_extension_attributes,
-      """Provides backwards compatibility for v1 atom.AtomBase classes.""")
-
-  def _get_tag(self, version=1):
-    qname = _get_qname(self, version)
-    if qname:
-      return qname[qname.find('}')+1:]
-    return None
-
-  def _get_namespace(self, version=1):
-    qname = _get_qname(self, version)
-    if qname.startswith('{'):
-      return qname[1:qname.find('}')]
-    else:
-      return None
-
-  def _set_tag(self, tag):
-    if isinstance(self._qname, tuple):
-      self._qname = self._qname.copy()
-      if self._qname[0].startswith('{'):
-        self._qname[0] = '{%s}%s' % (self._get_namespace(1), tag)
-      else:
-        self._qname[0] = tag
-    else:
-      if self._qname is not None and self._qname.startswith('{'):
-        self._qname = '{%s}%s' % (self._get_namespace(), tag)
-      else:
-        self._qname = tag
-
-  def _set_namespace(self, namespace):
-    tag = self._get_tag(1)
-    if tag is None:
-      tag = ''
-    if isinstance(self._qname, tuple):
-      self._qname = self._qname.copy()
-      if namespace:
-         self._qname[0] = '{%s}%s' % (namespace, tag)
-      else:
-         self._qname[0] = tag
-    else:
-      if namespace:
-         self._qname = '{%s}%s' % (namespace, tag)
-      else:
-         self._qname = tag
-
-  tag = property(_get_tag, _set_tag,
-      """Provides backwards compatibility for v1 atom.AtomBase classes.""")
-
-  namespace = property(_get_namespace, _set_namespace,
-      """Provides backwards compatibility for v1 atom.AtomBase classes.""")
-
-  # Provided for backwards compatibility to atom.ExtensionElement
-  children = extension_elements
-  attributes = extension_attributes
-
-
-def _get_qname(element, version):
-  if isinstance(element._qname, tuple):
-    if version <= len(element._qname):
-      return element._qname[version-1]
-    else:
-      return element._qname[-1]
-  else:
-    return element._qname
-
-
-def _qname_matches(tag, namespace, qname):
-  """Logic determines if a QName matches the desired local tag and namespace.
-
-  This is used in XmlElement.get_elements and XmlElement.get_attributes to
-  find matches in the element's members (among all expected-and-unexpected
-  elements-and-attributes).
-
-  Args:
-    expected_tag: string
-    expected_namespace: string
-    qname: string in the form '{xml_namespace}localtag' or 'tag' if there is
-           no namespace.
-
-  Returns:
-    boolean True if the member's tag and namespace fit the expected tag and
-    namespace.
-  """
-  # If there is no expected namespace or tag, then everything will match.
-  if qname is None:
-    member_tag = None
-    member_namespace = None
-  else:
-    if qname.startswith('{'):
-      member_namespace = qname[1:qname.index('}')]
-      member_tag = qname[qname.index('}') + 1:]
-    else:
-      member_namespace = None
-      member_tag = qname
-  return ((tag is None and namespace is None)
-      # If there is a tag, but no namespace, see if the local tag matches.
-      or (namespace is None and member_tag == tag)
-      # There was no tag, but there was a namespace so see if the namespaces
-      # match.
-      or (tag is None and member_namespace == namespace)
-      # There was no tag, and the desired elements have no namespace, so check
-      # to see that the member's namespace is None.
-      or (tag is None and namespace == ''
-          and member_namespace is None)
-      # The tag and the namespace both match.
-      or (tag == member_tag
-          and namespace == member_namespace)
-      # The tag matches, and the expected namespace is the empty namespace,
-      # check to make sure the member's namespace is None.
-      or (tag == member_tag and namespace == ''
-          and member_namespace is None))
-
-
-def parse(xml_string, target_class=None, version=1, encoding=None):
-  """Parses the XML string according to the rules for the target_class.
-
-  Args:
-    xml_string: str or unicode
-    target_class: XmlElement or a subclass. If None is specified, the
-        XmlElement class is used.
-    version: int (optional) The version of the schema which should be used when
-        converting the XML into an object. The default is 1.
-    encoding: str (optional) The character encoding of the bytes in the
-        xml_string. Default is 'UTF-8'.
-  """
-  if target_class is None:
-    target_class = XmlElement
-  if isinstance(xml_string, unicode):
-    if encoding is None:
-      xml_string = xml_string.encode(STRING_ENCODING)
-    else:
-      xml_string = xml_string.encode(encoding)
-  tree = ElementTree.fromstring(xml_string)
-  return _xml_element_from_tree(tree, target_class, version)
-
-
-Parse = parse
-xml_element_from_string = parse
-XmlElementFromString = xml_element_from_string
-
-
-def _xml_element_from_tree(tree, target_class, version=1):
-  if target_class._qname is None:
-    instance = target_class()
-    instance._qname = tree.tag
-    instance._harvest_tree(tree, version)
-    return instance
-  # TODO handle the namespace-only case
-  # Namespace only will be used with Google Spreadsheets rows and
-  # Google Base item attributes.
-  elif tree.tag == _get_qname(target_class, version):
-    instance = target_class()
-    instance._harvest_tree(tree, version)
-    return instance
-  return None
-
-
-class XmlAttribute(object):
-
-  def __init__(self, qname, value):
-    self._qname = qname
-    self.value = value
-

atom/data.py

@@ -1,338 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2009 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# This module is used for version 2 of the Google Data APIs.
-
-
-__author__ = 'j.s@google.com (Jeff Scudder)'
-
-
-import atom.core
-
-
-XML_TEMPLATE = '{http://www.w3.org/XML/1998/namespace}%s'
-ATOM_TEMPLATE = '{http://www.w3.org/2005/Atom}%s'
-APP_TEMPLATE_V1 = '{http://purl.org/atom/app#}%s'
-APP_TEMPLATE_V2 = '{http://www.w3.org/2007/app}%s'
-
-
-class Name(atom.core.XmlElement):
-  """The atom:name element."""
-  _qname = ATOM_TEMPLATE % 'name'
-
-
-class Email(atom.core.XmlElement):
-  """The atom:email element."""
-  _qname = ATOM_TEMPLATE % 'email'
-
-
-class Uri(atom.core.XmlElement):
-  """The atom:uri element."""
-  _qname = ATOM_TEMPLATE % 'uri'
-
-
-class Person(atom.core.XmlElement):
-  """A foundation class which atom:author and atom:contributor extend.
-
-  A person contains information like name, email address, and web page URI for
-  an author or contributor to an Atom feed.
-  """
-  name = Name
-  email = Email
-  uri = Uri
-
-
-class Author(Person):
-  """The atom:author element.
-
-  An author is a required element in Feed unless each Entry contains an Author.
-  """
-  _qname = ATOM_TEMPLATE % 'author'
-
-
-class Contributor(Person):
-  """The atom:contributor element."""
-  _qname = ATOM_TEMPLATE % 'contributor'
-
-
-class Link(atom.core.XmlElement):
-  """The atom:link element."""
-  _qname = ATOM_TEMPLATE % 'link'
-  href = 'href'
-  rel = 'rel'
-  type = 'type'
-  hreflang = 'hreflang'
-  title = 'title'
-  length = 'length'
-
-
-class Generator(atom.core.XmlElement):
-  """The atom:generator element."""
-  _qname = ATOM_TEMPLATE % 'generator'
-  uri = 'uri'
-  version = 'version'
-
-
-class Text(atom.core.XmlElement):
-  """A foundation class from which atom:title, summary, etc. extend.
-
-  This class should never be instantiated.
-  """
-  type = 'type'
-
-
-class Title(Text):
-  """The atom:title element."""
-  _qname = ATOM_TEMPLATE % 'title'
-
-
-class Subtitle(Text):
-  """The atom:subtitle element."""
-  _qname = ATOM_TEMPLATE % 'subtitle'
-
-
-class Rights(Text):
-  """The atom:rights element."""
-  _qname = ATOM_TEMPLATE % 'rights'
-
-
-class Summary(Text):
-  """The atom:summary element."""
-  _qname = ATOM_TEMPLATE % 'summary'
-
-
-class Content(Text):
-  """The atom:content element."""
-  _qname = ATOM_TEMPLATE % 'content'
-  src = 'src'
-
-
-class Category(atom.core.XmlElement):
-  """The atom:category element."""
-  _qname = ATOM_TEMPLATE % 'category'
-  term = 'term'
-  scheme = 'scheme'
-  label = 'label'
-
-
-class Id(atom.core.XmlElement):
-  """The atom:id element."""
-  _qname = ATOM_TEMPLATE % 'id'
-
-
-class Icon(atom.core.XmlElement):
-  """The atom:icon element."""
-  _qname = ATOM_TEMPLATE % 'icon'
-
-
-class Logo(atom.core.XmlElement):
-  """The atom:logo element."""
-  _qname = ATOM_TEMPLATE % 'logo'
-
-
-class Draft(atom.core.XmlElement):
-  """The app:draft element which indicates if this entry should be public."""
-  _qname = (APP_TEMPLATE_V1 % 'draft', APP_TEMPLATE_V2 % 'draft')
-
-
-class Control(atom.core.XmlElement):
-  """The app:control element indicating restrictions on publication.
-
-  The APP control element may contain a draft element indicating whether or
-  not this entry should be publicly available.
-  """
-  _qname = (APP_TEMPLATE_V1 % 'control', APP_TEMPLATE_V2 % 'control')
-  draft = Draft
-
-
-class Date(atom.core.XmlElement):
-  """A parent class for atom:updated, published, etc."""
-
-
-class Updated(Date):
-  """The atom:updated element."""
-  _qname = ATOM_TEMPLATE % 'updated'
-
-
-class Published(Date):
-  """The atom:published element."""
-  _qname = ATOM_TEMPLATE % 'published'
-
-
-class LinkFinder(object):
-  """An "interface" providing methods to find link elements
-
-  Entry elements often contain multiple links which differ in the rel
-  attribute or content type. Often, developers are interested in a specific
-  type of link so this class provides methods to find specific classes of
-  links.
-
-  This class is used as a mixin in Atom entries and feeds.
-  """
-
-  def find_url(self, rel):
-    """Returns the URL (as a string) in a link with the desired rel value."""
-    for link in self.link:
-      if link.rel == rel and link.href:
-        return link.href
-    return None
-
-  FindUrl = find_url
-
-  def get_link(self, rel):
-    """Returns a link object which has the desired rel value.
-
-    If you are interested in the URL instead of the link object,
-    consider using find_url instead.
-    """
-    for link in self.link:
-      if link.rel == rel and link.href:
-        return link
-    return None
-
-  GetLink = get_link
-
-  def find_self_link(self):
-    """Find the first link with rel set to 'self'
-
-    Returns:
-      A str containing the link's href or None if none of the links had rel
-      equal to 'self'
-    """
-    return self.find_url('self')
-
-  FindSelfLink = find_self_link
-
-  def get_self_link(self):
-    return self.get_link('self')
-
-  GetSelfLink = get_self_link
-
-  def find_edit_link(self):
-    return self.find_url('edit')
-
-  FindEditLink = find_edit_link
-
-  def get_edit_link(self):
-    return self.get_link('edit')
-
-  GetEditLink = get_edit_link
-
-  def find_edit_media_link(self):
-    link = self.find_url('edit-media')
-    # Search for media-edit as well since Picasa API used media-edit instead.
-    if link is None:
-      return self.find_url('media-edit')
-    return link
-
-  FindEditMediaLink = find_edit_media_link
-
-  def get_edit_media_link(self):
-    link = self.get_link('edit-media')
-    if link is None:
-      return self.get_link('media-edit')
-    return link
-
-  GetEditMediaLink = get_edit_media_link
-
-  def find_next_link(self):
-    return self.find_url('next')
-
-  FindNextLink = find_next_link
-
-  def get_next_link(self):
-    return self.get_link('next')
-
-  GetNextLink = get_next_link
-
-  def find_license_link(self):
-    return self.find_url('license')
-
-  FindLicenseLink = find_license_link
-
-  def get_license_link(self):
-    return self.get_link('license')
-
-  GetLicenseLink = get_license_link
-
-  def find_alternate_link(self):
-    return self.find_url('alternate')
-
-  FindAlternateLink = find_alternate_link
-
-  def get_alternate_link(self):
-    return self.get_link('alternate')
-
-  GetAlternateLink = get_alternate_link
-
-
-class FeedEntryParent(atom.core.XmlElement, LinkFinder):
-  """A super class for atom:feed and entry, contains shared attributes"""
-  author = [Author]
-  category = [Category]
-  contributor = [Contributor]
-  id = Id
-  link = [Link]
-  rights = Rights
-  title = Title
-  updated = Updated
-
-  def __init__(self, atom_id=None, text=None, *args, **kwargs):
-    if atom_id is not None:
-      self.id = atom_id
-    atom.core.XmlElement.__init__(self, text=text, *args, **kwargs)
-
-
-class Source(FeedEntryParent):
-  """The atom:source element."""
-  _qname = ATOM_TEMPLATE % 'source'
-  generator = Generator
-  icon = Icon
-  logo = Logo
-  subtitle = Subtitle
-
-
-class Entry(FeedEntryParent):
-  """The atom:entry element."""
-  _qname = ATOM_TEMPLATE % 'entry'
-  content = Content
-  published = Published
-  source = Source
-  summary = Summary
-  control = Control
-
-
-class Feed(Source):
-  """The atom:feed element which contains entries."""
-  _qname = ATOM_TEMPLATE % 'feed'
-  entry = [Entry]
-
-
-class ExtensionElement(atom.core.XmlElement):
-  """Provided for backwards compatibility to the v1 atom.ExtensionElement."""
-
-  def __init__(self, tag=None, namespace=None, attributes=None,
-      children=None, text=None, *args, **kwargs):
-    if namespace:
-      self._qname = '{%s}%s' % (namespace, tag)
-    else:
-      self._qname = tag
-    self.children = children or []
-    self.attributes = attributes or {}
-    self.text = text
-
-  _BecomeChildElement = atom.core.XmlElement._become_child

atom/http.py

@@ -1,364 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""HttpClients in this module use httplib to make HTTP requests.
-
-This module make HTTP requests based on httplib, but there are environments
-in which an httplib based approach will not work (if running in Google App
-Engine for example). In those cases, higher level classes (like AtomService
-and GDataService) can swap out the HttpClient to transparently use a 
-different mechanism for making HTTP requests.
-
-  HttpClient: Contains a request method which performs an HTTP call to the 
-      server.
-      
-  ProxiedHttpClient: Contains a request method which connects to a proxy using
-      settings stored in operating system environment variables then 
-      performs an HTTP call to the endpoint server.
-"""
-
-
-__author__ = 'api.jscudder (Jeff Scudder)'
-
-
-import types
-import os
-import httplib
-import atom.url
-import atom.http_interface
-import socket
-import base64
-import atom.http_core
-ssl_imported = False
-ssl = None
-try:
-  import ssl
-  ssl_imported = True
-except ImportError:
-  pass
-  
-
-
-class ProxyError(atom.http_interface.Error):
-  pass
-
-
-class TestConfigurationError(Exception):
-  pass
-
-
-DEFAULT_CONTENT_TYPE = 'application/atom+xml; charset=UTF-8'
-
-
-class HttpClient(atom.http_interface.GenericHttpClient):
-  # Added to allow old v1 HttpClient objects to use the new 
-  # http_code.HttpClient. Used in unit tests to inject a mock client.
-  v2_http_client = None
-
-  def __init__(self, headers=None):
-    self.debug = False
-    self.headers = headers or {}
-
-  def request(self, operation, url, data=None, headers=None):
-    """Performs an HTTP call to the server, supports GET, POST, PUT, and 
-    DELETE.
-
-    Usage example, perform and HTTP GET on http://www.google.com/:
-      import atom.http
-      client = atom.http.HttpClient()
-      http_response = client.request('GET', 'http://www.google.com/')
-
-    Args:
-      operation: str The HTTP operation to be performed. This is usually one
-          of 'GET', 'POST', 'PUT', or 'DELETE'
-      data: filestream, list of parts, or other object which can be converted
-          to a string. Should be set to None when performing a GET or DELETE.
-          If data is a file-like object which can be read, this method will 
-          read a chunk of 100K bytes at a time and send them. 
-          If the data is a list of parts to be sent, each part will be 
-          evaluated and sent.
-      url: The full URL to which the request should be sent. Can be a string
-          or atom.url.Url.
-      headers: dict of strings. HTTP headers which should be sent
-          in the request. 
-    """
-    all_headers = self.headers.copy()
-    if headers:
-      all_headers.update(headers)
-
-    # If the list of headers does not include a Content-Length, attempt to
-    # calculate it based on the data object.
-    if data and 'Content-Length' not in all_headers:
-      if isinstance(data, types.StringTypes):
-        all_headers['Content-Length'] = str(len(data))
-      else:
-        raise atom.http_interface.ContentLengthRequired('Unable to calculate '
-            'the length of the data parameter. Specify a value for '
-            'Content-Length')
-
-    # Set the content type to the default value if none was set.
-    if 'Content-Type' not in all_headers:
-      all_headers['Content-Type'] = DEFAULT_CONTENT_TYPE
-
-    if self.v2_http_client is not None:
-      http_request = atom.http_core.HttpRequest(method=operation)
-      atom.http_core.Uri.parse_uri(str(url)).modify_request(http_request)
-      http_request.headers = all_headers
-      if data:
-        http_request._body_parts.append(data)
-      return self.v2_http_client.request(http_request=http_request)
-
-    if not isinstance(url, atom.url.Url):
-      if isinstance(url, types.StringTypes):
-        url = atom.url.parse_url(url)
-      else:
-        raise atom.http_interface.UnparsableUrlObject('Unable to parse url '
-            'parameter because it was not a string or atom.url.Url')
-    
-    connection = self._prepare_connection(url, all_headers)
-
-    if self.debug:
-      connection.debuglevel = 1
-
-    connection.putrequest(operation, self._get_access_url(url), 
-        skip_host=True)
-    if url.port is not None:
-      connection.putheader('Host', '%s:%s' % (url.host, url.port))
-    else:
-      connection.putheader('Host', url.host)
-
-    # Overcome a bug in Python 2.4 and 2.5
-    # httplib.HTTPConnection.putrequest adding
-    # HTTP request header 'Host: www.google.com:443' instead of
-    # 'Host: www.google.com', and thus resulting the error message
-    # 'Token invalid - AuthSub token has wrong scope' in the HTTP response.
-    if (url.protocol == 'https' and int(url.port or 443) == 443 and
-        hasattr(connection, '_buffer') and
-        isinstance(connection._buffer, list)):
-      header_line = 'Host: %s:443' % url.host
-      replacement_header_line = 'Host: %s' % url.host
-      try:
-        connection._buffer[connection._buffer.index(header_line)] = (
-            replacement_header_line)
-      except ValueError:  # header_line missing from connection._buffer
-        pass
-
-    # Send the HTTP headers.
-    for header_name in all_headers:
-      connection.putheader(header_name, all_headers[header_name])
-    connection.endheaders()
-
-    # If there is data, send it in the request.
-    if data:
-      if isinstance(data, list):
-        for data_part in data:
-          _send_data_part(data_part, connection)
-      else:
-        _send_data_part(data, connection)
-
-    # Return the HTTP Response from the server.
-    return connection.getresponse()
-    
-  def _prepare_connection(self, url, headers):
-    if not isinstance(url, atom.url.Url):
-      if isinstance(url, types.StringTypes):
-        url = atom.url.parse_url(url)
-      else:
-        raise atom.http_interface.UnparsableUrlObject('Unable to parse url '
-            'parameter because it was not a string or atom.url.Url')
-    if url.protocol == 'https':
-      if not url.port:
-        return httplib.HTTPSConnection(url.host)
-      return httplib.HTTPSConnection(url.host, int(url.port))
-    else:
-      if not url.port:
-        return httplib.HTTPConnection(url.host)
-      return httplib.HTTPConnection(url.host, int(url.port))
-
-  def _get_access_url(self, url):
-    return url.to_string()
-
-
-class ProxiedHttpClient(HttpClient):
-  """Performs an HTTP request through a proxy.
-  
-  The proxy settings are obtained from enviroment variables. The URL of the 
-  proxy server is assumed to be stored in the environment variables 
-  'https_proxy' and 'http_proxy' respectively. If the proxy server requires
-  a Basic Auth authorization header, the username and password are expected to 
-  be in the 'proxy-username' or 'proxy_username' variable and the 
-  'proxy-password' or 'proxy_password' variable, or in 'http_proxy' or
-  'https_proxy' as "protocol://[username:password@]host:port".
-  
-  After connecting to the proxy server, the request is completed as in 
-  HttpClient.request.
-  """
-  def _prepare_connection(self, url, headers):
-    proxy_settings = os.environ.get('%s_proxy' % url.protocol)
-    if not proxy_settings:
-      # The request was HTTP or HTTPS, but there was no appropriate proxy set.
-      return HttpClient._prepare_connection(self, url, headers)
-    else:
-      #print '!!!!%s' % proxy_settings
-      proxy_auth = _get_proxy_auth(proxy_settings)
-      proxy_netloc = _get_proxy_net_location(proxy_settings)
-      #print '!!!!%s' % proxy_auth
-      #print '!!!!%s' % proxy_netloc
-      if url.protocol == 'https':
-        # Set any proxy auth headers 
-        if proxy_auth:
-          proxy_auth = 'Proxy-authorization: %s' % proxy_auth
-          
-        # Construct the proxy connect command.
-        port = url.port
-        if not port:
-          port = '443'
-        proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % (url.host, port)
-        
-        # Set the user agent to send to the proxy
-        if headers and 'User-Agent' in headers:
-          user_agent = 'User-Agent: %s\r\n' % (headers['User-Agent'])
-        else:
-          user_agent = 'User-Agent: python\r\n'
-        
-        proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth, user_agent)
-        
-        # Find the proxy host and port.
-        proxy_url = atom.url.parse_url(proxy_netloc)
-        if not proxy_url.port:
-          proxy_url.port = '80'
-        
-        # Connect to the proxy server, very simple recv and error checking
-        p_sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
-        p_sock.connect((proxy_url.host, int(proxy_url.port)))
-        p_sock.sendall(proxy_pieces)
-        response = ''
-
-        # Wait for the full response.
-        while response.find("\r\n\r\n") == -1:
-          response += p_sock.recv(8192)
-       
-        p_status = response.split()[1]
-        if p_status != str(200):
-          raise ProxyError('Error status=%s' % str(p_status))
-
-        # Trivial setup for ssl socket.
-        sslobj = None
-        if ssl_imported:
-          sslobj = ssl.wrap_socket(p_sock, None, None)
-        else:
-          sock_ssl = socket.ssl(p_sock, None, None)
-          sslobj = httplib.FakeSocket(p_sock, sock_ssl)
- 
-        # Initalize httplib and replace with the proxy socket.
-        connection = httplib.HTTPConnection(proxy_url.host)
-        connection.sock = sslobj
-        return connection
-      else:
-        # If protocol was not https.
-        # Find the proxy host and port.
-        proxy_url = atom.url.parse_url(proxy_netloc)
-        if not proxy_url.port:
-          proxy_url.port = '80'
-        
-        if proxy_auth:
-          headers['Proxy-Authorization'] = proxy_auth.strip()
-
-        return httplib.HTTPConnection(proxy_url.host, int(proxy_url.port))
-
-  def _get_access_url(self, url):
-    return url.to_string()
-
-
-def _get_proxy_auth(proxy_settings):
-  """Returns proxy authentication string for header.
-
-  Will check environment variables for proxy authentication info, starting with
-  proxy(_/-)username and proxy(_/-)password before checking the given
-  proxy_settings for a [protocol://]username:password@host[:port] string.
-
-  Args:
-    proxy_settings: String from http_proxy or https_proxy environment variable.
-
-  Returns:
-    Authentication string for proxy, or empty string if no proxy username was
-    found.
-  """
-  proxy_username = None
-  proxy_password = None
-
-  proxy_username = os.environ.get('proxy-username')
-  if not proxy_username:
-    proxy_username = os.environ.get('proxy_username')
-  proxy_password = os.environ.get('proxy-password')
-  if not proxy_password:
-    proxy_password = os.environ.get('proxy_password')
-
-  if not proxy_username:
-    if '@' in proxy_settings:
-      protocol_and_proxy_auth = proxy_settings.split('@')[0].split(':')
-      if len(protocol_and_proxy_auth) == 3:
-        # 3 elements means we have [<protocol>, //<user>, <password>]
-        proxy_username = protocol_and_proxy_auth[1].lstrip('/')
-        proxy_password = protocol_and_proxy_auth[2]
-      elif len(protocol_and_proxy_auth) == 2:
-        # 2 elements means we have [<user>, <password>]
-        proxy_username = protocol_and_proxy_auth[0]
-        proxy_password = protocol_and_proxy_auth[1]
-  if proxy_username:
-    user_auth = base64.encodestring('%s:%s' % (proxy_username,
-                                               proxy_password))
-    return 'Basic %s\r\n' % (user_auth.strip())
-  else:
-    return ''
-
-
-def _get_proxy_net_location(proxy_settings):
-  """Returns proxy host and port.
-
-  Args:
-    proxy_settings: String from http_proxy or https_proxy environment variable.
-        Must be in the form of protocol://[username:password@]host:port
-
-  Returns:
-    String in the form of protocol://host:port
-  """
-  if '@' in proxy_settings:
-    protocol = proxy_settings.split(':')[0]
-    netloc = proxy_settings.split('@')[1]
-    return '%s://%s' % (protocol, netloc)
-  else:
-    return proxy_settings
-
-
-def _send_data_part(data, connection):
-  if isinstance(data, types.StringTypes):
-    connection.send(data)
-    return
-  # Check to see if data is a file-like object that has a read method.
-  elif hasattr(data, 'read'):
-    # Read the file and send it a chunk at a time.
-    while 1:
-      binarydata = data.read(100000)
-      if binarydata == '': break
-      connection.send(binarydata)
-    return
-  else:
-    # The data object was not a file.
-    # Try to convert to a string and send the data.
-    connection.send(str(data))
-    return

atom/http_core.py

@@ -1,597 +0,0 @@
-#!/usr/bin/env python
-#
-#    Copyright (C) 2009 Google Inc.
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-
-# This module is used for version 2 of the Google Data APIs.
-# TODO: add proxy handling.
-
-
-__author__ = 'j.s@google.com (Jeff Scudder)'
-
-
-import os
-import StringIO
-import urlparse
-import urllib
-import httplib
-ssl = None
-try:
-  import ssl
-except ImportError:
-  pass
-
-
-
-class Error(Exception):
-  pass
-
-
-class UnknownSize(Error):
-  pass
-
-
-class ProxyError(Error):
-  pass
-
-
-MIME_BOUNDARY = 'END_OF_PART'
-
-
-def get_headers(http_response):
-  """Retrieves all HTTP headers from an HTTP response from the server.
-  
-  This method is provided for backwards compatibility for Python2.2 and 2.3.
-  The httplib.HTTPResponse object in 2.2 and 2.3 does not have a getheaders
-  method so this function will use getheaders if available, but if not it
-  will retrieve a few using getheader.
-  """
-  if hasattr(http_response, 'getheaders'):
-    return http_response.getheaders()
-  else:
-    headers = []
-    for header in (
-        'location', 'content-type', 'content-length', 'age', 'allow',
-        'cache-control', 'content-location', 'content-encoding', 'date',
-        'etag', 'expires', 'last-modified', 'pragma', 'server',
-        'set-cookie', 'transfer-encoding', 'vary', 'via', 'warning',
-        'www-authenticate', 'gdata-version'):
-      value = http_response.getheader(header, None)
-      if value is not None:
-        headers.append((header, value))
-    return headers
-
-
-class HttpRequest(object):
-  """Contains all of the parameters for an HTTP 1.1 request.
-
-  The HTTP headers are represented by a dictionary, and it is the
-  responsibility of the user to ensure that duplicate field names are combined
-  into one header value according to the rules in section 4.2 of RFC 2616.
-  """
-  method = None
-  uri = None
-
-  def __init__(self, uri=None, method=None, headers=None):
-    """Construct an HTTP request.
-
-    Args:
-      uri: The full path or partial path as a Uri object or a string.
-      method: The HTTP method for the request, examples include 'GET', 'POST',
-              etc.
-      headers: dict of strings The HTTP headers to include in the request.
-    """
-    self.headers = headers or {}
-    self._body_parts = []
-    if method is not None:
-      self.method = method
-    if isinstance(uri, (str, unicode)):
-      uri = Uri.parse_uri(uri)
-    self.uri = uri or Uri()
-
-
-  def add_body_part(self, data, mime_type, size=None):
-    """Adds data to the HTTP request body.
-
-    If more than one part is added, this is assumed to be a mime-multipart
-    request. This method is designed to create MIME 1.0 requests as specified
-    in RFC 1341.
-
-    Args:
-      data: str or a file-like object containing a part of the request body.
-      mime_type: str The MIME type describing the data
-      size: int Required if the data is a file like object. If the data is a
-            string, the size is calculated so this parameter is ignored.
-    """
-    if isinstance(data, str):
-      size = len(data)
-    if size is None:
-      # TODO: support chunked transfer if some of the body is of unknown size.
-      raise UnknownSize('Each part of the body must have a known size.')
-    if 'Content-Length' in self.headers:
-      content_length = int(self.headers['Content-Length'])
-    else:
-      content_length = 0
-    # If this is the first part added to the body, then this is not a multipart
-    # request.
-    if len(self._body_parts) == 0:
-      self.headers['Content-Type'] = mime_type
-      content_length = size
-      self._body_parts.append(data)
-    elif len(self._body_parts) == 1:
-      # This is the first member in a mime-multipart request, so change the
-      # _body_parts list to indicate a multipart payload.
-      self._body_parts.insert(0, 'Media multipart posting')
-      boundary_string = '\r\n--%s\r\n' % (MIME_BOUNDARY,)
-      content_length += len(boundary_string) + size
-      self._body_parts.insert(1, boundary_string)
-      content_length += len('Media multipart posting')
-      # Put the content type of the first part of the body into the multipart
-      # payload.
-      original_type_string = 'Content-Type: %s\r\n\r\n' % (
-          self.headers['Content-Type'],)
-      self._body_parts.insert(2, original_type_string)
-      content_length += len(original_type_string)
-      boundary_string = '\r\n--%s\r\n' % (MIME_BOUNDARY,)
-      self._body_parts.append(boundary_string)
-      content_length += len(boundary_string)
-      # Change the headers to indicate this is now a mime multipart request.
-      self.headers['Content-Type'] = 'multipart/related; boundary="%s"' % (
-          MIME_BOUNDARY,)
-      self.headers['MIME-version'] = '1.0'
-      # Include the mime type of this part.
-      type_string = 'Content-Type: %s\r\n\r\n' % (mime_type)
-      self._body_parts.append(type_string)
-      content_length += len(type_string)
-      self._body_parts.append(data)
-      ending_boundary_string = '\r\n--%s--' % (MIME_BOUNDARY,)
-      self._body_parts.append(ending_boundary_string)
-      content_length += len(ending_boundary_string)
-    else:
-      # This is a mime multipart request.
-      boundary_string = '\r\n--%s\r\n' % (MIME_BOUNDARY,)
-      self._body_parts.insert(-1, boundary_string)
-      content_length += len(boundary_string) + size
-      # Include the mime type of this part.
-      type_string = 'Content-Type: %s\r\n\r\n' % (mime_type)
-      self._body_parts.insert(-1, type_string)
-      content_length += len(type_string)
-      self._body_parts.insert(-1, data)
-    self.headers['Content-Length'] = str(content_length)
-  # I could add an "append_to_body_part" method as well.
-
-  AddBodyPart = add_body_part
-
-  def add_form_inputs(self, form_data,
-                      mime_type='application/x-www-form-urlencoded'):
-    """Form-encodes and adds data to the request body.
-
-    Args:
-      form_data: dict or sequnce or two member tuples which contains the
-                 form keys and values.
-      mime_type: str The MIME type of the form data being sent. Defaults
-                 to 'application/x-www-form-urlencoded'.
-    """
-    body = urllib.urlencode(form_data)
-    self.add_body_part(body, mime_type)
-
-  AddFormInputs = add_form_inputs
-
-  def _copy(self):
-    """Creates a deep copy of this request."""
-    copied_uri = Uri(self.uri.scheme, self.uri.host, self.uri.port,
-                     self.uri.path, self.uri.query.copy())
-    new_request = HttpRequest(uri=copied_uri, method=self.method,
-                              headers=self.headers.copy())
-    new_request._body_parts = self._body_parts[:]
-    return new_request
-
-  def _dump(self):
-    """Converts to a printable string for debugging purposes.
-    
-    In order to preserve the request, it does not read from file-like objects
-    in the body.
-    """
-    output =  'HTTP Request\n  method: %s\n  url: %s\n  headers:\n' % (
-        self.method, str(self.uri))
-    for header, value in self.headers.iteritems():
-      output += '    %s: %s\n' % (header, value)
-    output += '  body sections:\n'
-    i = 0
-    for part in self._body_parts:
-      if isinstance(part, (str, unicode)):
-        output += '    %s: %s\n' % (i, part)
-      else:
-        output += '    %s: <file like object>\n' % i
-      i += 1
-    return output
-
-
-def _apply_defaults(http_request):
-  if http_request.uri.scheme is None:
-    if http_request.uri.port == 443:
-      http_request.uri.scheme = 'https'
-    else:
-      http_request.uri.scheme = 'http'
-
-
-class Uri(object):
-  """A URI as used in HTTP 1.1"""
-  scheme = None
-  host = None
-  port = None
-  path = None
-
-  def __init__(self, scheme=None, host=None, port=None, path=None, query=None):
-    """Constructor for a URI.
-
-    Args:
-      scheme: str This is usually 'http' or 'https'.
-      host: str The host name or IP address of the desired server.
-      post: int The server's port number.
-      path: str The path of the resource following the host. This begins with
-            a /, example: '/calendar/feeds/default/allcalendars/full'
-      query: dict of strings The URL query parameters. The keys and values are
-             both escaped so this dict should contain the unescaped values.
-             For example {'my key': 'val', 'second': '!!!'} will become
-             '?my+key=val&second=%21%21%21' which is appended to the path.
-    """
-    self.query = query or {}
-    if scheme is not None:
-      self.scheme = scheme
-    if host is not None:
-      self.host = host
-    if port is not None:
-      self.port = port
-    if path:
-      self.path = path
-
-  def _get_query_string(self):
-    param_pairs = []
-    for key, value in self.query.iteritems():
-      param_pairs.append('='.join((urllib.quote_plus(key),
-          urllib.quote_plus(str(value)))))
-    return '&'.join(param_pairs)
-
-  def _get_relative_path(self):
-    """Returns the path with the query parameters escaped and appended."""
-    param_string = self._get_query_string()
-    if self.path is None:
-      path = '/'
-    else:
-      path = self.path
-    if param_string:
-      return '?'.join([path, param_string])
-    else:
-      return path
-
-  def _to_string(self):
-    if self.scheme is None and self.port == 443:
-      scheme = 'https'
-    elif self.scheme is None:
-      scheme = 'http'
-    else:
-      scheme = self.scheme
-    if self.path is None:
-      path = '/'
-    else:
-      path = self.path
-    if self.port is None:
-      return '%s://%s%s' % (scheme, self.host, self._get_relative_path())
-    else:
-      return '%s://%s:%s%s' % (scheme, self.host, str(self.port),
-                               self._get_relative_path())
-
-  def __str__(self):
-    return self._to_string()
-
-  def modify_request(self, http_request=None):
-    """Sets HTTP request components based on the URI."""
-    if http_request is None:
-      http_request = HttpRequest()
-    if http_request.uri is None:
-      http_request.uri = Uri()
-    # Determine the correct scheme.
-    if self.scheme:
-      http_request.uri.scheme = self.scheme
-    if self.port:
-      http_request.uri.port = self.port
-    if self.host:
-      http_request.uri.host = self.host
-    # Set the relative uri path
-    if self.path:
-      http_request.uri.path = self.path
-    if self.query:
-      http_request.uri.query = self.query.copy()
-    return http_request
-
-  ModifyRequest = modify_request
-
-  def parse_uri(uri_string):
-    """Creates a Uri object which corresponds to the URI string.
-
-    This method can accept partial URIs, but it will leave missing
-    members of the Uri unset.
-    """
-    parts = urlparse.urlparse(uri_string)
-    uri = Uri()
-    if parts[0]:
-      uri.scheme = parts[0]
-    if parts[1]:
-      host_parts = parts[1].split(':')
-      if host_parts[0]:
-        uri.host = host_parts[0]
-      if len(host_parts) > 1:
-        uri.port = int(host_parts[1])
-    if parts[2]:
-      uri.path = parts[2]
-    if parts[4]:
-      param_pairs = parts[4].split('&')
-      for pair in param_pairs:
-        pair_parts = pair.split('=')
-        if len(pair_parts) > 1:
-          uri.query[urllib.unquote_plus(pair_parts[0])] = (
-              urllib.unquote_plus(pair_parts[1]))
-        elif len(pair_parts) == 1:
-          uri.query[urllib.unquote_plus(pair_parts[0])] = None
-    return uri
-
-  parse_uri = staticmethod(parse_uri)
-
-  ParseUri = parse_uri
-
-
-parse_uri = Uri.parse_uri
-
-
-ParseUri = Uri.parse_uri
-
-
-class HttpResponse(object):
-  status = None
-  reason = None
-  _body = None
-
-  def __init__(self, status=None, reason=None, headers=None, body=None):
-    self._headers = headers or {}
-    if status is not None:
-      self.status = status
-    if reason is not None:
-      self.reason = reason
-    if body is not None:
-      if hasattr(body, 'read'):
-        self._body = body
-      else:
-        self._body = StringIO.StringIO(body)
-
-  def getheader(self, name, default=None):
-    if name in self._headers:
-      return self._headers[name]
-    else:
-      return default
-
-  def getheaders(self):
-    return self._headers
-
-  def read(self, amt=None):
-    if self._body is None:
-      return None
-    if not amt:
-      return self._body.read()
-    else:
-      return self._body.read(amt)
-
-
-def _dump_response(http_response):
-  """Converts to a string for printing debug messages.
-  
-  Does not read the body since that may consume the content.
-  """
-  output = 'HttpResponse\n  status: %s\n  reason: %s\n  headers:' % (
-      http_response.status, http_response.reason)
-  headers = get_headers(http_response)
-  if isinstance(headers, dict):
-    for header, value in headers.iteritems():
-      output += '    %s: %s\n' % (header, value)
-  else:
-    for pair in headers:
-      output += '    %s: %s\n' % (pair[0], pair[1])
-  return output
-
-
-class HttpClient(object):
-  """Performs HTTP requests using httplib."""
-  debug = None
-
-  def request(self, http_request):
-    return self._http_request(http_request.method, http_request.uri,
-                              http_request.headers, http_request._body_parts)
-
-  Request = request
-
-  def _get_connection(self, uri, headers=None):
-    """Opens a socket connection to the server to set up an HTTP request.
-
-    Args:
-      uri: The full URL for the request as a Uri object.
-      headers: A dict of string pairs containing the HTTP headers for the
-          request.
-    """
-    connection = None
-    if uri.scheme == 'https':
-      if not uri.port:
-        connection = httplib.HTTPSConnection(uri.host)
-      else:
-        connection = httplib.HTTPSConnection(uri.host, int(uri.port))
-    else:
-      if not uri.port:
-        connection = httplib.HTTPConnection(uri.host)
-      else:
-        connection = httplib.HTTPConnection(uri.host, int(uri.port))
-    return connection
-
-  def _http_request(self, method, uri, headers=None, body_parts=None):
-    """Makes an HTTP request using httplib.
-
-    Args:
-      method: str example: 'GET', 'POST', 'PUT', 'DELETE', etc.
-      uri: str or atom.http_core.Uri
-      headers: dict of strings mapping to strings which will be sent as HTTP
-               headers in the request.
-      body_parts: list of strings, objects with a read method, or objects
-                  which can be converted to strings using str. Each of these
-                  will be sent in order as the body of the HTTP request.
-    """
-    if isinstance(uri, (str, unicode)):
-      uri = Uri.parse_uri(uri)
-
-    connection = self._get_connection(uri, headers=headers)
-
-    if self.debug:
-      connection.debuglevel = 1
-
-    if connection.host != uri.host:
-      connection.putrequest(method, str(uri))
-    else:
-      connection.putrequest(method, uri._get_relative_path())
-
-    # Overcome a bug in Python 2.4 and 2.5
-    # httplib.HTTPConnection.putrequest adding
-    # HTTP request header 'Host: www.google.com:443' instead of
-    # 'Host: www.google.com', and thus resulting the error message
-    # 'Token invalid - AuthSub token has wrong scope' in the HTTP response.
-    if (uri.scheme == 'https' and int(uri.port or 443) == 443 and
-        hasattr(connection, '_buffer') and
-        isinstance(connection._buffer, list)):
-      header_line = 'Host: %s:443' % uri.host
-      replacement_header_line = 'Host: %s' % uri.host
-      try:
-        connection._buffer[connection._buffer.index(header_line)] = (
-            replacement_header_line)
-      except ValueError:  # header_line missing from connection._buffer
-        pass
-
-    # Send the HTTP headers.
-    for header_name, value in headers.iteritems():
-      connection.putheader(header_name, value)
-    connection.endheaders()
-
-    # If there is data, send it in the request.
-    if body_parts and filter(lambda x: x != '', body_parts):
-      for part in body_parts:
-        _send_data_part(part, connection)
-
-    # Return the HTTP Response from the server.
-    return connection.getresponse()
-
-
-def _send_data_part(data, connection):
-  if isinstance(data, (str, unicode)):
-    # I might want to just allow str, not unicode.
-    connection.send(data)
-    return
-  # Check to see if data is a file-like object that has a read method.
-  elif hasattr(data, 'read'):
-    # Read the file and send it a chunk at a time.
-    while 1:
-      binarydata = data.read(100000)
-      if binarydata == '': break
-      connection.send(binarydata)
-    return
-  else:
-    # The data object was not a file.
-    # Try to convert to a string and send the data.
-    connection.send(str(data))
-    return
-
-
-class ProxiedHttpClient(HttpClient):
-
-  def _get_connection(self, uri, headers=None):
-    # Check to see if there are proxy settings required for this request.
-    proxy = None
-    if uri.scheme == 'https':
-      proxy = os.environ.get('https_proxy')
-    elif uri.scheme == 'http':
-      proxy = os.environ.get('http_proxy')
-    if not proxy:
-      return HttpClient._get_connection(self, uri, headers=headers)
-    # Now we have the URL of the appropriate proxy server.
-    # Get a username and password for the proxy if required.
-    proxy_auth = _get_proxy_auth()
-    if uri.scheme == 'https':
-      import socket
-      if proxy_auth:
-        proxy_auth = 'Proxy-authorization: %s' % proxy_auth
-      # Construct the proxy connect command.
-      port = uri.port
-      if not port:
-        port = 443
-      proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % (uri.host, port)
-      # Set the user agent to send to the proxy
-      user_agent = ''
-      if headers and 'User-Agent' in headers:
-        user_agent = 'User-Agent: %s\r\n' % (headers['User-Agent'])
-      proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth, user_agent)
-      # Find the proxy host and port.
-      proxy_uri = Uri.parse_uri(proxy)
-      if not proxy_uri.port:
-        proxy_uri.port = '80'
-      # Connect to the proxy server, very simple recv and error checking
-      p_sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
-      p_sock.connect((proxy_uri.host, int(proxy_uri.port)))
-      p_sock.sendall(proxy_pieces)
-      response = ''
-      # Wait for the full response.
-      while response.find("\r\n\r\n") == -1:
-        response += p_sock.recv(8192)
-      p_status = response.split()[1]
-      if p_status != str(200):
-        raise ProxyError('Error status=%s' % str(p_status))
-      # Trivial setup for ssl socket.
-      sslobj = None
-      if ssl is not None:
-        sslobj = ssl.wrap_socket(p_sock, None, None)
-      else:
-        sock_ssl = socket.ssl(p_sock, None, Nonesock_)
-        sslobj = httplib.FakeSocket(p_sock, sock_ssl)
-      # Initalize httplib and replace with the proxy socket.
-      connection = httplib.HTTPConnection(proxy_uri.host)
-      connection.sock = sslobj
-      return connection
-    elif uri.scheme == 'http':
-      proxy_uri = Uri.parse_uri(proxy)
-      if not proxy_uri.port:
-        proxy_uri.port = '80'
-      if proxy_auth:
-        headers['Proxy-Authorization'] = proxy_auth.strip()
-      return httplib.HTTPConnection(proxy_uri.host, int(proxy_uri.port))
-    return None
-
-
-def _get_proxy_auth():
-  import base64
-  proxy_username = os.environ.get('proxy-username')
-  if not proxy_username:
-    proxy_username = os.environ.get('proxy_username')
-  proxy_password = os.environ.get('proxy-password')
-  if not proxy_password:
-    proxy_password = os.environ.get('proxy_password')
-  if proxy_username:
-    user_auth = base64.b64encode('%s:%s' % (proxy_username,
-                                            proxy_password))
-    return 'Basic %s\r\n' % (user_auth.strip())
-  else:
-    return ''

atom/http_interface.py

@@ -1,156 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""This module provides a common interface for all HTTP requests.
-
-  HttpResponse: Represents the server's response to an HTTP request. Provides
-      an interface identical to httplib.HTTPResponse which is the response
-      expected from higher level classes which use HttpClient.request.
-
-  GenericHttpClient: Provides an interface (superclass) for an object 
-      responsible for making HTTP requests. Subclasses of this object are
-      used in AtomService and GDataService to make requests to the server. By
-      changing the http_client member object, the AtomService is able to make
-      HTTP requests using different logic (for example, when running on 
-      Google App Engine, the http_client makes requests using the App Engine
-      urlfetch API). 
-"""
-
-
-__author__ = 'api.jscudder (Jeff Scudder)'
-
-
-import StringIO
-
-
-USER_AGENT = '%s GData-Python 2.0.14+20110902+custom_mods'
-
-
-class Error(Exception):
-  pass
-
-
-class UnparsableUrlObject(Error):
-  pass
-
-
-class ContentLengthRequired(Error):
-  pass
-  
-
-class HttpResponse(object):
-  def __init__(self, body=None, status=None, reason=None, headers=None):
-    """Constructor for an HttpResponse object. 
-
-    HttpResponse represents the server's response to an HTTP request from
-    the client. The HttpClient.request method returns a httplib.HTTPResponse
-    object and this HttpResponse class is designed to mirror the interface
-    exposed by httplib.HTTPResponse.
-
-    Args:
-      body: A file like object, with a read() method. The body could also
-          be a string, and the constructor will wrap it so that 
-          HttpResponse.read(self) will return the full string.
-      status: The HTTP status code as an int. Example: 200, 201, 404.
-      reason: The HTTP status message which follows the code. Example: 
-          OK, Created, Not Found
-      headers: A dictionary containing the HTTP headers in the server's 
-          response. A common header in the response is Content-Length.
-    """
-    if body:
-      if hasattr(body, 'read'):
-        self._body = body
-      else:
-        self._body = StringIO.StringIO(body)
-    else:
-      self._body = None
-    if status is not None:
-      self.status = int(status)
-    else:
-      self.status = None
-    self.reason = reason
-    self._headers = headers or {}
-
-  def getheader(self, name, default=None):
-    if name in self._headers:
-      return self._headers[name]
-    else:
-      return default
-    
-  def read(self, amt=None):
-    if not amt:
-      return self._body.read()
-    else:
-      return self._body.read(amt)
-
-
-class GenericHttpClient(object):
-  debug = False
-
-  def __init__(self, http_client, headers=None):
-    """
-    
-    Args:
-      http_client: An object which provides a request method to make an HTTP 
-          request. The request method in GenericHttpClient performs a 
-          call-through to the contained HTTP client object.
-      headers: A dictionary containing HTTP headers which should be included
-          in every HTTP request. Common persistent headers include 
-          'User-Agent'.
-    """
-    self.http_client = http_client
-    self.headers = headers or {}
-
-  def request(self, operation, url, data=None, headers=None):
-    all_headers = self.headers.copy()
-    if headers:
-      all_headers.update(headers)
-    return self.http_client.request(operation, url, data=data, 
-        headers=all_headers)
-
-  def get(self, url, headers=None):
-    return self.request('GET', url, headers=headers)
-
-  def post(self, url, data, headers=None):
-    return self.request('POST', url, data=data, headers=headers)
-
-  def put(self, url, data, headers=None):
-    return self.request('PUT', url, data=data, headers=headers)
-
-  def delete(self, url, headers=None):
-    return self.request('DELETE', url, headers=headers)
-
-
-class GenericToken(object):
-  """Represents an Authorization token to be added to HTTP requests.
-  
-  Some Authorization headers included calculated fields (digital
-  signatures for example) which are based on the parameters of the HTTP
-  request. Therefore the token is responsible for signing the request
-  and adding the Authorization header. 
-  """
-  def perform_request(self, http_client, operation, url, data=None, 
-                      headers=None):
-    """For the GenericToken, no Authorization token is set."""
-    return http_client.request(operation, url, data=data, headers=headers)
-
-  def valid_for_scope(self, url):
-    """Tells the caller if the token authorizes access to the desired URL.
-    
-    Since the generic token doesn't add an auth header, it is not valid for
-    any scope.
-    """
-    return False

atom/mock_http.py

@@ -1,132 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-__author__ = 'api.jscudder (Jeff Scudder)'
-
-
-import atom.http_interface
-import atom.url
-
-
-class Error(Exception):
-  pass
-
-
-class NoRecordingFound(Error):
-  pass
-
-
-class MockRequest(object):
-  """Holds parameters of an HTTP request for matching against future requests.
-  """
-  def __init__(self, operation, url, data=None, headers=None):
-    self.operation = operation
-    if isinstance(url, (str, unicode)):
-      url = atom.url.parse_url(url)
-    self.url = url
-    self.data = data
-    self.headers = headers
-
-
-class MockResponse(atom.http_interface.HttpResponse):
-  """Simulates an httplib.HTTPResponse object."""
-  def __init__(self, body=None, status=None, reason=None, headers=None):
-    if body and hasattr(body, 'read'):
-      self.body = body.read()
-    else:
-      self.body = body
-    if status is not None:
-      self.status = int(status)
-    else:
-      self.status = None
-    self.reason = reason
-    self._headers = headers or {}
-
-  def read(self):
-    return self.body
-
-
-class MockHttpClient(atom.http_interface.GenericHttpClient):
-  def __init__(self, headers=None, recordings=None, real_client=None):
-    """An HttpClient which responds to request with stored data.
-
-    The request-response pairs are stored as tuples in a member list named
-    recordings.
-
-    The MockHttpClient can be switched from replay mode to record mode by
-    setting the real_client member to an instance of an HttpClient which will
-    make real HTTP requests and store the server's response in list of 
-    recordings.
-    
-    Args:
-      headers: dict containing HTTP headers which should be included in all
-          HTTP requests.
-      recordings: The initial recordings to be used for responses. This list
-          contains tuples in the form: (MockRequest, MockResponse)
-      real_client: An HttpClient which will make a real HTTP request. The 
-          response will be converted into a MockResponse and stored in 
-          recordings.
-    """
-    self.recordings = recordings or []
-    self.real_client = real_client
-    self.headers = headers or {}
-
-  def add_response(self, response, operation, url, data=None, headers=None):
-    """Adds a request-response pair to the recordings list.
-    
-    After the recording is added, future matching requests will receive the
-    response.
-    
-    Args:
-      response: MockResponse
-      operation: str
-      url: str
-      data: str, Currently the data is ignored when looking for matching
-          requests.
-      headers: dict of strings: Currently the headers are ignored when
-          looking for matching requests.
-    """
-    request = MockRequest(operation, url, data=data, headers=headers)
-    self.recordings.append((request, response))
-
-  def request(self, operation, url, data=None, headers=None):
-    """Returns a matching MockResponse from the recordings.
-    
-    If the real_client is set, the request will be passed along and the 
-    server's response will be added to the recordings and also returned. 
-
-    If there is no match, a NoRecordingFound error will be raised.
-    """
-    if self.real_client is None:
-      if isinstance(url, (str, unicode)):
-        url = atom.url.parse_url(url)
-      for recording in self.recordings:
-        if recording[0].operation == operation and recording[0].url == url:
-          return recording[1]
-      raise NoRecordingFound('No recodings found for %s %s' % (
-          operation, url))
-    else:
-      # There is a real HTTP client, so make the request, and record the 
-      # response.
-      response = self.real_client.request(operation, url, data=data, 
-          headers=headers)
-      # TODO: copy the headers
-      stored_response = MockResponse(body=response, status=response.status,
-          reason=response.reason)
-      self.add_response(stored_response, operation, url, data=data, 
-          headers=headers)
-      return stored_response

atom/mock_http_core.py

@@ -1,323 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright (C) 2009 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# This module is used for version 2 of the Google Data APIs.
-
-
-__author__ = 'j.s@google.com (Jeff Scudder)'
-
-
-import StringIO
-import pickle
-import os.path
-import tempfile
-import atom.http_core
-
-
-class Error(Exception):
-  pass
-
-
-class NoRecordingFound(Error):
-  pass
-
-
-class MockHttpClient(object):
-  debug = None
-  real_client = None
-  last_request_was_live = False
-
-  # The following members are used to construct the session cache temp file
-  # name.
-  # These are combined to form the file name
-  # /tmp/cache_prefix.cache_case_name.cache_test_name
-  cache_name_prefix = 'gdata_live_test'
-  cache_case_name = ''
-  cache_test_name = ''
-
-  def __init__(self, recordings=None, real_client=None):
-    self._recordings = recordings or []
-    if real_client is not None:
-      self.real_client = real_client
-
-  def add_response(self, http_request, status, reason, headers=None,
-      body=None):
-    response = MockHttpResponse(status, reason, headers, body)
-    # TODO Scrub the request and the response.
-    self._recordings.append((http_request._copy(), response))
-
-  AddResponse = add_response
-
-  def request(self, http_request):
-    """Provide a recorded response, or record a response for replay.
-
-    If the real_client is set, the request will be made using the
-    real_client, and the response from the server will be recorded.
-    If the real_client is None (the default), this method will examine
-    the recordings and find the first which matches.
-    """
-    request = http_request._copy()
-    _scrub_request(request)
-    if self.real_client is None:
-      self.last_request_was_live = False
-      for recording in self._recordings:
-        if _match_request(recording[0], request):
-          return recording[1]
-    else:
-      # Pass along the debug settings to the real client.
-      self.real_client.debug = self.debug
-      # Make an actual request since we can use the real HTTP client.
-      self.last_request_was_live = True
-      response = self.real_client.request(http_request)
-      scrubbed_response = _scrub_response(response)
-      self.add_response(request, scrubbed_response.status,
-                        scrubbed_response.reason,
-                        dict(atom.http_core.get_headers(scrubbed_response)),
-                        scrubbed_response.read())
-      # Return the recording which we just added.
-      return self._recordings[-1][1]
-    raise NoRecordingFound('No recoding was found for request: %s %s' % (
-        request.method, str(request.uri)))
-
-  Request = request
-
-  def _save_recordings(self, filename):
-    recording_file = open(os.path.join(tempfile.gettempdir(), filename),
-                          'wb')
-    pickle.dump(self._recordings, recording_file)
-    recording_file.close()
-
-  def _load_recordings(self, filename):
-    recording_file = open(os.path.join(tempfile.gettempdir(), filename),
-                          'rb')
-    self._recordings = pickle.load(recording_file)
-    recording_file.close()
-
-  def _delete_recordings(self, filename):
-    full_path = os.path.join(tempfile.gettempdir(), filename)
-    if os.path.exists(full_path):
-      os.remove(full_path)
-
-  def _load_or_use_client(self, filename, http_client):
-    if os.path.exists(os.path.join(tempfile.gettempdir(), filename)):
-      self._load_recordings(filename)
-    else:
-      self.real_client = http_client
-
-  def use_cached_session(self, name=None, real_http_client=None):
-    """Attempts to load recordings from a previous live request.
-
-    If a temp file with the recordings exists, then it is used to fulfill
-    requests. If the file does not exist, then a real client is used to
-    actually make the desired HTTP requests. Requests and responses are
-    recorded and will be written to the desired temprary cache file when
-    close_session is called.
-
-    Args:
-      name: str (optional) The file name of session file to be used. The file
-            is loaded from the temporary directory of this machine. If no name
-            is passed in, a default name will be constructed using the
-            cache_name_prefix, cache_case_name, and cache_test_name of this
-            object.
-      real_http_client: atom.http_core.HttpClient the real client to be used
-                        if the cached recordings are not found. If the default
-                        value is used, this will be an
-                        atom.http_core.HttpClient.
-    """
-    if real_http_client is None:
-      real_http_client = atom.http_core.HttpClient()
-    if name is None:
-      self._recordings_cache_name = self.get_cache_file_name()
-    else:
-      self._recordings_cache_name = name
-    self._load_or_use_client(self._recordings_cache_name, real_http_client)
-
-  def close_session(self):
-    """Saves recordings in the temporary file named in use_cached_session."""
-    if self.real_client is not None:
-      self._save_recordings(self._recordings_cache_name)
-
-  def delete_session(self, name=None):
-    """Removes recordings from a previous live request."""
-    if name is None:
-      self._delete_recordings(self._recordings_cache_name)
-    else:
-      self._delete_recordings(name)
-
-  def get_cache_file_name(self):
-    return '%s.%s.%s' % (self.cache_name_prefix, self.cache_case_name,
-                         self.cache_test_name)
-
-  def _dump(self):
-    """Provides debug information in a string."""
-    output = 'MockHttpClient\n  real_client: %s\n  cache file name: %s\n' % (
-        self.real_client, self.get_cache_file_name())
-    output += '  recordings:\n'
-    i = 0
-    for recording in self._recordings:
-      output += '    recording %i is for: %s %s\n' % (
-          i, recording[0].method, str(recording[0].uri))
-      i += 1
-    return output
-
-
-def _match_request(http_request, stored_request):
-  """Determines whether a request is similar enough to a stored request
-     to cause the stored response to be returned."""
-  # Check to see if the host names match.
-  if (http_request.uri.host is not None
-      and http_request.uri.host != stored_request.uri.host):
-    return False
-  # Check the request path in the URL (/feeds/private/full/x)
-  elif http_request.uri.path != stored_request.uri.path:
-    return False
-  # Check the method used in the request (GET, POST, etc.)
-  elif http_request.method != stored_request.method:
-    return False
-  # If there is a gsession ID in either request, make sure that it is matched
-  # exactly.
-  elif ('gsessionid' in http_request.uri.query
-        or 'gsessionid' in stored_request.uri.query):
-    if 'gsessionid' not in stored_request.uri.query:
-      return False
-    elif 'gsessionid' not in http_request.uri.query:
-      return False
-    elif (http_request.uri.query['gsessionid']
-          != stored_request.uri.query['gsessionid']):
-      return False
-  # Ignores differences in the query params (?start-index=5&max-results=20),
-  # the body of the request, the port number, HTTP headers, just to name a
-  # few.
-  return True
-
-
-def _scrub_request(http_request):
-  """ Removes email address and password from a client login request.
-
-  Since the mock server saves the request and response in plantext, sensitive
-  information like the password should be removed before saving the
-  recordings. At the moment only requests sent to a ClientLogin url are
-  scrubbed.
-  """
-  if (http_request and http_request.uri and http_request.uri.path and
-      http_request.uri.path.endswith('ClientLogin')):
-    # Remove the email and password from a ClientLogin request.
-    http_request._body_parts = []
-    http_request.add_form_inputs(
-        {'form_data': 'client login request has been scrubbed'})
-  else:
-    # We can remove the body of the post from the recorded request, since
-    # the request body is not used when finding a matching recording.
-    http_request._body_parts = []
-  return http_request
-
-
-def _scrub_response(http_response):
-  return http_response
-
-
-class EchoHttpClient(object):
-  """Sends the request data back in the response.
-
-  Used to check the formatting of the request as it was sent. Always responds
-  with a 200 OK, and some information from the HTTP request is returned in
-  special Echo-X headers in the response. The following headers are added
-  in the response:
-  'Echo-Host': The host name and port number to which the HTTP connection is
-               made. If no port was passed in, the header will contain
-               host:None.
-  'Echo-Uri': The path portion of the URL being requested. /example?x=1&y=2
-  'Echo-Scheme': The beginning of the URL, usually 'http' or 'https'
-  'Echo-Method': The HTTP method being used, 'GET', 'POST', 'PUT', etc.
-  """
-
-  def request(self, http_request):
-    return self._http_request(http_request.uri, http_request.method,
-                              http_request.headers, http_request._body_parts)
-
-  def _http_request(self, uri, method, headers=None, body_parts=None):
-    body = StringIO.StringIO()
-    response = atom.http_core.HttpResponse(status=200, reason='OK', body=body)
-    if headers is None:
-      response._headers = {}
-    else:
-      # Copy headers from the request to the response but convert values to
-      # strings. Server response headers always come in as strings, so an int
-      # should be converted to a corresponding string when echoing.
-      for header, value in headers.iteritems():
-        response._headers[header] = str(value)
-    response._headers['Echo-Host'] = '%s:%s' % (uri.host, str(uri.port))
-    response._headers['Echo-Uri'] = uri._get_relative_path()
-    response._headers['Echo-Scheme'] = uri.scheme
-    response._headers['Echo-Method'] = method
-    for part in body_parts:
-      if isinstance(part, str):
-        body.write(part)
-      elif hasattr(part, 'read'):
-        body.write(part.read())
-    body.seek(0)
-    return response
-
-
-class SettableHttpClient(object):
-  """An HTTP Client which responds with the data given in set_response."""
-
-  def __init__(self, status, reason, body, headers):
-    """Configures the response for the server.
-
-    See set_response for details on the arguments to the constructor.
-    """
-    self.set_response(status, reason, body, headers)
-    self.last_request = None
-
-  def set_response(self, status, reason, body, headers):
-    """Determines the response which will be sent for each request.
-
-    Args:
-      status: An int for the HTTP status code, example: 200, 404, etc.
-      reason: String for the HTTP reason, example: OK, NOT FOUND, etc.
-      body: The body of the HTTP response as a string or a file-like
-            object (something with a read method).
-      headers: dict of strings containing the HTTP headers in the response.
-    """
-    self.response = atom.http_core.HttpResponse(status=status, reason=reason,
-        body=body)
-    self.response._headers = headers.copy()
-
-  def request(self, http_request):
-    self.last_request = http_request
-    return self.response
-
-
-class MockHttpResponse(atom.http_core.HttpResponse):
-
-  def __init__(self, status=None, reason=None, headers=None, body=None):
-    self._headers = headers or {}
-    if status is not None:
-      self.status = status
-    if reason is not None:
-      self.reason = reason
-    if body is not None:
-      # Instead of using a file-like object for the body, store as a string
-      # so that reads can be repeated.
-      if hasattr(body, 'read'):
-        self._body = body.read()
-      else:
-        self._body = body
-
-  def read(self):
-    return self._body

atom/mock_service.py

@@ -1,243 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""MockService provides CRUD ops. for mocking calls to AtomPub services.
-
-  MockService: Exposes the publicly used methods of AtomService to provide
-      a mock interface which can be used in unit tests.
-"""
-
-import atom.service
-import pickle
-
-
-__author__ = 'api.jscudder (Jeffrey Scudder)'
-
-
-# Recordings contains pairings of HTTP MockRequest objects with MockHttpResponse objects.
-recordings = []
-# If set, the mock service HttpRequest are actually made through this object.
-real_request_handler = None
-
-def ConcealValueWithSha(source):
-  import sha
-  return sha.new(source[:-5]).hexdigest()
-
-def DumpRecordings(conceal_func=ConcealValueWithSha):
-  if conceal_func:
-    for recording_pair in recordings:
-      recording_pair[0].ConcealSecrets(conceal_func)
-  return pickle.dumps(recordings)
-
-def LoadRecordings(recordings_file_or_string):
-  if isinstance(recordings_file_or_string, str):
-    atom.mock_service.recordings =  pickle.loads(recordings_file_or_string)
-  elif hasattr(recordings_file_or_string, 'read'):
-    atom.mock_service.recordings = pickle.loads(
-      recordings_file_or_string.read())
-
-def HttpRequest(service, operation, data, uri, extra_headers=None,
-    url_params=None, escape_params=True, content_type='application/atom+xml'):
-  """Simulates an HTTP call to the server, makes an actual HTTP request if 
-  real_request_handler is set.
-
-  This function operates in two different modes depending on if 
-  real_request_handler is set or not. If real_request_handler is not set,
-  HttpRequest will look in this module's recordings list to find a response
-  which matches the parameters in the function call. If real_request_handler
-  is set, this function will call real_request_handler.HttpRequest, add the
-  response to the recordings list, and respond with the actual response.
-
-  Args:
-    service: atom.AtomService object which contains some of the parameters
-        needed to make the request. The following members are used to
-        construct the HTTP call: server (str), additional_headers (dict),
-        port (int), and ssl (bool).
-    operation: str The HTTP operation to be performed. This is usually one of
-        'GET', 'POST', 'PUT', or 'DELETE'
-    data: ElementTree, filestream, list of parts, or other object which can be
-        converted to a string.
-        Should be set to None when performing a GET or PUT.
-        If data is a file-like object which can be read, this method will read
-        a chunk of 100K bytes at a time and send them.
-        If the data is a list of parts to be sent, each part will be evaluated
-        and sent.
-    uri: The beginning of the URL to which the request should be sent.
-        Examples: '/', '/base/feeds/snippets',
-        '/m8/feeds/contacts/default/base'
-    extra_headers: dict of strings. HTTP headers which should be sent
-        in the request. These headers are in addition to those stored in
-        service.additional_headers.
-    url_params: dict of strings. Key value pairs to be added to the URL as
-        URL parameters. For example {'foo':'bar', 'test':'param'} will
-        become ?foo=bar&test=param.
-    escape_params: bool default True. If true, the keys and values in
-        url_params will be URL escaped when the form is constructed
-        (Special characters converted to %XX form.)
-    content_type: str The MIME type for the data being sent. Defaults to
-        'application/atom+xml', this is only used if data is set.
-  """
-  full_uri = atom.service.BuildUri(uri, url_params, escape_params)
-  (server, port, ssl, uri) = atom.service.ProcessUrl(service, uri)
-  current_request = MockRequest(operation, full_uri, host=server, ssl=ssl, 
-      data=data, extra_headers=extra_headers, url_params=url_params, 
-      escape_params=escape_params, content_type=content_type)
-  # If the request handler is set, we should actually make the request using 
-  # the request handler and record the response to replay later.
-  if real_request_handler:
-    response = real_request_handler.HttpRequest(service, operation, data, uri,
-        extra_headers=extra_headers, url_params=url_params, 
-        escape_params=escape_params, content_type=content_type)
-    # TODO: need to copy the HTTP headers from the real response into the
-    # recorded_response.
-    recorded_response = MockHttpResponse(body=response.read(), 
-        status=response.status, reason=response.reason)
-    # Insert a tuple which maps the request to the response object returned
-    # when making an HTTP call using the real_request_handler.
-    recordings.append((current_request, recorded_response))
-    return recorded_response
-  else:
-    # Look through available recordings to see if one matches the current 
-    # request.
-    for request_response_pair in recordings:
-      if request_response_pair[0].IsMatch(current_request):
-        return request_response_pair[1]
-  return None
-
-
-class MockRequest(object):
-  """Represents a request made to an AtomPub server.
-  
-  These objects are used to determine if a client request matches a recorded
-  HTTP request to determine what the mock server's response will be. 
-  """
-
-  def __init__(self, operation, uri, host=None, ssl=False, port=None, 
-      data=None, extra_headers=None, url_params=None, escape_params=True,
-      content_type='application/atom+xml'):
-    """Constructor for a MockRequest
-    
-    Args:
-      operation: str One of 'GET', 'POST', 'PUT', or 'DELETE' this is the
-          HTTP operation requested on the resource.
-      uri: str The URL describing the resource to be modified or feed to be
-          retrieved. This should include the protocol (http/https) and the host
-          (aka domain). For example, these are some valud full_uris:
-          'http://example.com', 'https://www.google.com/accounts/ClientLogin'
-      host: str (optional) The server name which will be placed at the 
-          beginning of the URL if the uri parameter does not begin with 'http'.
-          Examples include 'example.com', 'www.google.com', 'www.blogger.com'.
-      ssl: boolean (optional) If true, the request URL will begin with https 
-          instead of http.
-      data: ElementTree, filestream, list of parts, or other object which can be
-          converted to a string. (optional)
-          Should be set to None when performing a GET or PUT.
-          If data is a file-like object which can be read, the constructor 
-          will read the entire file into memory. If the data is a list of 
-          parts to be sent, each part will be evaluated and stored.
-      extra_headers: dict (optional) HTTP headers included in the request.
-      url_params: dict (optional) Key value pairs which should be added to 
-          the URL as URL parameters in the request. For example uri='/', 
-          url_parameters={'foo':'1','bar':'2'} could become '/?foo=1&bar=2'.
-      escape_params: boolean (optional) Perform URL escaping on the keys and 
-          values specified in url_params. Defaults to True.
-      content_type: str (optional) Provides the MIME type of the data being 
-          sent.
-    """
-    self.operation = operation
-    self.uri = _ConstructFullUrlBase(uri, host=host, ssl=ssl)
-    self.data = data
-    self.extra_headers = extra_headers
-    self.url_params = url_params or {}
-    self.escape_params = escape_params
-    self.content_type = content_type
-
-  def ConcealSecrets(self, conceal_func):
-    """Conceal secret data in this request."""
-    if self.extra_headers.has_key('Authorization'):
-      self.extra_headers['Authorization'] = conceal_func(
-        self.extra_headers['Authorization'])
-
-  def IsMatch(self, other_request):
-    """Check to see if the other_request is equivalent to this request.
-    
-    Used to determine if a recording matches an incoming request so that a
-    recorded response should be sent to the client.
-
-    The matching is not exact, only the operation and URL are examined 
-    currently.
-
-    Args:
-      other_request: MockRequest The request which we want to check this
-          (self) MockRequest against to see if they are equivalent.
-    """
-    # More accurate matching logic will likely be required.
-    return (self.operation == other_request.operation and self.uri == 
-        other_request.uri)
-
-
-def _ConstructFullUrlBase(uri, host=None, ssl=False):
-  """Puts URL components into the form http(s)://full.host.strinf/uri/path
-  
-  Used to construct a roughly canonical URL so that URLs which begin with 
-  'http://example.com/' can be compared to a uri of '/' when the host is 
-  set to 'example.com'
-
-  If the uri contains 'http://host' already, the host and ssl parameters
-  are ignored.
-
-  Args:
-    uri: str The path component of the URL, examples include '/'
-    host: str (optional) The host name which should prepend the URL. Example:
-        'example.com'
-    ssl: boolean (optional) If true, the returned URL will begin with https
-        instead of http.
-
-  Returns:
-    String which has the form http(s)://example.com/uri/string/contents
-  """
-  if uri.startswith('http'):
-    return uri
-  if ssl:
-    return 'https://%s%s' % (host, uri)
-  else:
-    return 'http://%s%s' % (host, uri)
-
-
-class MockHttpResponse(object):
-  """Returned from MockService crud methods as the server's response."""
-
-  def __init__(self, body=None, status=None, reason=None, headers=None):
-    """Construct a mock HTTPResponse and set members.
-
-    Args:
-      body: str (optional) The HTTP body of the server's response. 
-      status: int (optional) 
-      reason: str (optional)
-      headers: dict (optional)
-    """
-    self.body = body
-    self.status = status
-    self.reason = reason
-    self.headers = headers or {}
-
-  def read(self):
-    return self.body
-
-  def getheader(self, header_name):
-    return self.headers[header_name]
-

atom/service.py

@@ -1,745 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2006, 2007, 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""AtomService provides CRUD ops. in line with the Atom Publishing Protocol.
-
-  AtomService: Encapsulates the ability to perform insert, update and delete
-               operations with the Atom Publishing Protocol on which GData is
-               based. An instance can perform query, insertion, deletion, and
-               update.
-
-  HttpRequest: Function that performs a GET, POST, PUT, or DELETE HTTP request
-       to the specified end point. An AtomService object or a subclass can be
-       used to specify information about the request.
-"""
-
-__author__ = 'api.jscudder (Jeff Scudder)'
-
-
-import atom.http_interface
-import atom.url
-import atom.http
-import atom.token_store
-
-import os
-import types
-import httplib
-import urllib
-import re
-import base64
-import socket
-import warnings
-try:
-  from xml.etree import cElementTree as ElementTree
-except ImportError:
-  try:
-    import cElementTree as ElementTree
-  except ImportError:
-    try:
-      from xml.etree import ElementTree
-    except ImportError:
-      from elementtree import ElementTree
-import atom
-
-
-class AtomService(object):
-  """Performs Atom Publishing Protocol CRUD operations.
-  
-  The AtomService contains methods to perform HTTP CRUD operations. 
-  """
-
-  # Default values for members
-  port = 80
-  ssl = False 
-  # Set the current_token to force the AtomService to use this token
-  # instead of searching for an appropriate token in the token_store.
-  current_token = None
-  auto_store_tokens = True
-  auto_set_current_token = True
-
-  def _get_override_token(self):
-    return self.current_token
-
-  def _set_override_token(self, token):
-    self.current_token = token
-
-  override_token = property(_get_override_token, _set_override_token)
-
-  #@atom.v1_deprecated('Please use atom.client.AtomPubClient instead.')
-  def __init__(self, server=None, additional_headers=None, 
-      application_name='', http_client=None, token_store=None):
-    """Creates a new AtomService client.
-    
-    Args:
-      server: string (optional) The start of a URL for the server
-              to which all operations should be directed. Example: 
-              'www.google.com'
-      additional_headers: dict (optional) Any additional HTTP headers which
-                          should be included with CRUD operations.
-      http_client: An object responsible for making HTTP requests using a
-                   request method. If none is provided, a new instance of
-                   atom.http.ProxiedHttpClient will be used.
-      token_store: Keeps a collection of authorization tokens which can be
-                   applied to requests for a specific URLs. Critical methods are
-                   find_token based on a URL (atom.url.Url or a string), add_token,
-                   and remove_token.
-    """
-    self.http_client = http_client or atom.http.ProxiedHttpClient()
-    self.token_store = token_store or atom.token_store.TokenStore()
-    self.server = server
-    self.additional_headers = additional_headers or {}
-    self.additional_headers['User-Agent'] = atom.http_interface.USER_AGENT % (
-        application_name,)
-    # If debug is True, the HTTPConnection will display debug information
-    self._set_debug(False)
-
-  __init__ = atom.v1_deprecated(
-      'Please use atom.client.AtomPubClient instead.')(
-          __init__)
-
-  def _get_debug(self):
-    return self.http_client.debug
-
-  def _set_debug(self, value):
-    self.http_client.debug = value
-
-  debug = property(_get_debug, _set_debug, 
-      doc='If True, HTTP debug information is printed.')
-
-  def use_basic_auth(self, username, password, scopes=None):
-    if username is not None and password is not None:
-      if scopes is None:
-        scopes = [atom.token_store.SCOPE_ALL]
-      base_64_string = base64.encodestring('%s:%s' % (username, password))
-      token = BasicAuthToken('Basic %s' % base_64_string.strip(), 
-          scopes=[atom.token_store.SCOPE_ALL])
-      if self.auto_set_current_token:
-        self.current_token = token
-      if self.auto_store_tokens:
-        return self.token_store.add_token(token)
-      return True
-    return False
-
-  def UseBasicAuth(self, username, password, for_proxy=False):
-    """Sets an Authenticaiton: Basic HTTP header containing plaintext.
-
-    Deprecated, use use_basic_auth instead.
-    
-    The username and password are base64 encoded and added to an HTTP header
-    which will be included in each request. Note that your username and 
-    password are sent in plaintext.
-
-    Args:
-      username: str
-      password: str
-    """
-    self.use_basic_auth(username, password)
-
-  #@atom.v1_deprecated('Please use atom.client.AtomPubClient for requests.')
-  def request(self, operation, url, data=None, headers=None, 
-      url_params=None):
-    if isinstance(url, (str, unicode)):
-      if url.startswith('http:') and self.ssl:
-        # Force all requests to be https if self.ssl is True.
-        url = atom.url.parse_url('https:' + url[5:])
-      elif not url.startswith('http') and self.ssl: 
-        url = atom.url.parse_url('https://%s%s' % (self.server, url))
-      elif not url.startswith('http'):
-        url = atom.url.parse_url('http://%s%s' % (self.server, url))
-      else:
-        url = atom.url.parse_url(url)
-
-    if url_params:
-      for name, value in url_params.iteritems():
-        url.params[name] = value
-
-    all_headers = self.additional_headers.copy()
-    if headers:
-      all_headers.update(headers)
-
-    if isinstance(data, types.StringTypes):
-      data = data.encode('utf-8')
-    
-    # If the list of headers does not include a Content-Length, attempt to
-    # calculate it based on the data object.
-    if data and 'Content-Length' not in all_headers:
-      content_length = CalculateDataLength(data)
-      if content_length:
-        all_headers['Content-Length'] = str(content_length)
-
-    all_headers['GData-Version'] = '2.0'
-    # Find an Authorization token for this URL if one is available.
-    if self.override_token:
-      auth_token = self.override_token
-    else:
-      auth_token = self.token_store.find_token(url)
-    return auth_token.perform_request(self.http_client, operation, url, 
-        data=data, headers=all_headers)
-
-  request = atom.v1_deprecated(
-      'Please use atom.client.AtomPubClient for requests.')(
-          request)
-
-  # CRUD operations
-  def Get(self, uri, extra_headers=None, url_params=None, escape_params=True):
-    """Query the APP server with the given URI
-
-    The uri is the portion of the URI after the server value 
-    (server example: 'www.google.com').
-
-    Example use:
-    To perform a query against Google Base, set the server to 
-    'base.google.com' and set the uri to '/base/feeds/...', where ... is 
-    your query. For example, to find snippets for all digital cameras uri 
-    should be set to: '/base/feeds/snippets?bq=digital+camera'
-
-    Args:
-      uri: string The query in the form of a URI. Example:
-           '/base/feeds/snippets?bq=digital+camera'.
-      extra_headers: dicty (optional) Extra HTTP headers to be included
-                     in the GET request. These headers are in addition to 
-                     those stored in the client's additional_headers property.
-                     The client automatically sets the Content-Type and 
-                     Authorization headers.
-      url_params: dict (optional) Additional URL parameters to be included
-                  in the query. These are translated into query arguments
-                  in the form '&dict_key=value&...'.
-                  Example: {'max-results': '250'} becomes &max-results=250
-      escape_params: boolean (optional) If false, the calling code has already
-                     ensured that the query will form a valid URL (all
-                     reserved characters have been escaped). If true, this
-                     method will escape the query and any URL parameters
-                     provided.
-
-    Returns:
-      httplib.HTTPResponse The server's response to the GET request.
-    """
-    return self.request('GET', uri, data=None, headers=extra_headers, 
-                        url_params=url_params)
-
-  def Post(self, data, uri, extra_headers=None, url_params=None, 
-           escape_params=True, content_type='application/atom+xml; charset=UTF-8'):
-    """Insert data into an APP server at the given URI.
-
-    Args:
-      data: string, ElementTree._Element, or something with a __str__ method 
-            The XML to be sent to the uri. 
-      uri: string The location (feed) to which the data should be inserted. 
-           Example: '/base/feeds/items'. 
-      extra_headers: dict (optional) HTTP headers which are to be included. 
-                     The client automatically sets the Content-Type,
-                     Authorization, and Content-Length headers.
-      url_params: dict (optional) Additional URL parameters to be included
-                  in the URI. These are translated into query arguments
-                  in the form '&dict_key=value&...'.
-                  Example: {'max-results': '250'} becomes &max-results=250
-      escape_params: boolean (optional) If false, the calling code has already
-                     ensured that the query will form a valid URL (all
-                     reserved characters have been escaped). If true, this
-                     method will escape the query and any URL parameters
-                     provided.
-
-    Returns:
-      httplib.HTTPResponse Server's response to the POST request.
-    """
-    if extra_headers is None:
-      extra_headers = {}
-    if content_type:
-      extra_headers['Content-Type'] = content_type
-    return self.request('POST', uri, data=data, headers=extra_headers, 
-                        url_params=url_params)
-
-  def Put(self, data, uri, extra_headers=None, url_params=None, 
-           escape_params=True, content_type='application/atom+xml; charset=UTF-8'):
-    """Updates an entry at the given URI.
-     
-    Args:
-      data: string, ElementTree._Element, or xml_wrapper.ElementWrapper The 
-            XML containing the updated data.
-      uri: string A URI indicating entry to which the update will be applied.
-           Example: '/base/feeds/items/ITEM-ID'
-      extra_headers: dict (optional) HTTP headers which are to be included.
-                     The client automatically sets the Content-Type,
-                     Authorization, and Content-Length headers.
-      url_params: dict (optional) Additional URL parameters to be included
-                  in the URI. These are translated into query arguments
-                  in the form '&dict_key=value&...'.
-                  Example: {'max-results': '250'} becomes &max-results=250
-      escape_params: boolean (optional) If false, the calling code has already
-                     ensured that the query will form a valid URL (all
-                     reserved characters have been escaped). If true, this
-                     method will escape the query and any URL parameters
-                     provided.
-  
-    Returns:
-      httplib.HTTPResponse Server's response to the PUT request.
-    """
-    if extra_headers is None:
-      extra_headers = {}
-    if content_type:
-      extra_headers['Content-Type'] = content_type
-    return self.request('PUT', uri, data=data, headers=extra_headers, 
-                        url_params=url_params)
-
-  def Delete(self, uri, extra_headers=None, url_params=None, 
-             escape_params=True):
-    """Deletes the entry at the given URI.
-
-    Args:
-      uri: string The URI of the entry to be deleted. Example: 
-           '/base/feeds/items/ITEM-ID'
-      extra_headers: dict (optional) HTTP headers which are to be included.
-                     The client automatically sets the Content-Type and
-                     Authorization headers.
-      url_params: dict (optional) Additional URL parameters to be included
-                  in the URI. These are translated into query arguments
-                  in the form '&dict_key=value&...'.
-                  Example: {'max-results': '250'} becomes &max-results=250
-      escape_params: boolean (optional) If false, the calling code has already
-                     ensured that the query will form a valid URL (all
-                     reserved characters have been escaped). If true, this
-                     method will escape the query and any URL parameters
-                     provided.
-
-    Returns:
-      httplib.HTTPResponse Server's response to the DELETE request.
-    """
-    return self.request('DELETE', uri, data=None, headers=extra_headers, 
-                        url_params=url_params)
-
-
-class BasicAuthToken(atom.http_interface.GenericToken):
-  def __init__(self, auth_header, scopes=None):
-    """Creates a token used to add Basic Auth headers to HTTP requests.
-
-    Args:
-      auth_header: str The value for the Authorization header.
-      scopes: list of str or atom.url.Url specifying the beginnings of URLs
-          for which this token can be used. For example, if scopes contains
-          'http://example.com/foo', then this token can be used for a request to
-          'http://example.com/foo/bar' but it cannot be used for a request to
-          'http://example.com/baz'
-    """
-    self.auth_header = auth_header
-    self.scopes = scopes or []
-
-  def perform_request(self, http_client, operation, url, data=None,
-                      headers=None):
-    """Sets the Authorization header to the basic auth string."""
-    if headers is None:
-      headers = {'Authorization':self.auth_header}
-    else:
-      headers['Authorization'] = self.auth_header
-    return http_client.request(operation, url, data=data, headers=headers)
-
-  def __str__(self):
-    return self.auth_header
-
-  def valid_for_scope(self, url):
-    """Tells the caller if the token authorizes access to the desired URL.
-    """
-    if isinstance(url, (str, unicode)):
-      url = atom.url.parse_url(url)
-    for scope in self.scopes:
-      if scope == atom.token_store.SCOPE_ALL:
-        return True
-      if isinstance(scope, (str, unicode)):
-        scope = atom.url.parse_url(scope)
-      if scope == url:
-        return True
-      # Check the host and the path, but ignore the port and protocol.
-      elif scope.host == url.host and not scope.path:
-        return True
-      elif scope.host == url.host and scope.path and not url.path:
-        continue
-      elif scope.host == url.host and url.path.startswith(scope.path):
-        return True
-    return False
-
-
-def PrepareConnection(service, full_uri):
-  """Opens a connection to the server based on the full URI.
-
-  This method is deprecated, instead use atom.http.HttpClient.request.
-
-  Examines the target URI and the proxy settings, which are set as
-  environment variables, to open a connection with the server. This
-  connection is used to make an HTTP request.
-
-  Args:
-    service: atom.AtomService or a subclass. It must have a server string which
-      represents the server host to which the request should be made. It may also
-      have a dictionary of additional_headers to send in the HTTP request.
-    full_uri: str Which is the target relative (lacks protocol and host) or
-    absolute URL to be opened. Example:
-    'https://www.google.com/accounts/ClientLogin' or
-    'base/feeds/snippets' where the server is set to www.google.com.
-
-  Returns:
-    A tuple containing the httplib.HTTPConnection and the full_uri for the
-    request.
-  """
-  deprecation('calling deprecated function PrepareConnection')
-  (server, port, ssl, partial_uri) = ProcessUrl(service, full_uri)
-  if ssl:
-    # destination is https
-    proxy = os.environ.get('https_proxy')
-    if proxy:
-      (p_server, p_port, p_ssl, p_uri) = ProcessUrl(service, proxy, True)
-      proxy_username = os.environ.get('proxy-username')
-      if not proxy_username:
-        proxy_username = os.environ.get('proxy_username')
-      proxy_password = os.environ.get('proxy-password')
-      if not proxy_password:
-        proxy_password = os.environ.get('proxy_password')
-      if proxy_username:
-        user_auth = base64.encodestring('%s:%s' % (proxy_username,
-                                                   proxy_password))
-        proxy_authorization = ('Proxy-authorization: Basic %s\r\n' % (
-            user_auth.strip()))
-      else:
-        proxy_authorization = ''
-      proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % (server, port)
-      user_agent = 'User-Agent: %s\r\n' % (
-          service.additional_headers['User-Agent'])
-      proxy_pieces = (proxy_connect + proxy_authorization + user_agent
-                       + '\r\n')
-
-      #now connect, very simple recv and error checking
-      p_sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
-      p_sock.connect((p_server,p_port))
-      p_sock.sendall(proxy_pieces)
-      response = ''
-
-      # Wait for the full response.
-      while response.find("\r\n\r\n") == -1:
-        response += p_sock.recv(8192)
-       
-      p_status=response.split()[1]
-      if p_status!=str(200):
-        raise atom.http.ProxyError('Error status=%s' % p_status)
-
-      # Trivial setup for ssl socket.
-      ssl = socket.ssl(p_sock, None, None)
-      fake_sock = httplib.FakeSocket(p_sock, ssl)
-
-      # Initalize httplib and replace with the proxy socket.
-      connection = httplib.HTTPConnection(server)
-      connection.sock=fake_sock
-      full_uri = partial_uri
-
-    else:
-      connection = httplib.HTTPSConnection(server, port)
-      full_uri = partial_uri
-
-  else:
-    # destination is http
-    proxy = os.environ.get('http_proxy')
-    if proxy:
-      (p_server, p_port, p_ssl, p_uri) = ProcessUrl(service.server, proxy, True)
-      proxy_username = os.environ.get('proxy-username')
-      if not proxy_username:
-        proxy_username = os.environ.get('proxy_username')
-      proxy_password = os.environ.get('proxy-password')
-      if not proxy_password:
-        proxy_password = os.environ.get('proxy_password')
-      if proxy_username:
-        UseBasicAuth(service, proxy_username, proxy_password, True)
-      connection = httplib.HTTPConnection(p_server, p_port)
-      if not full_uri.startswith("http://"):
-        if full_uri.startswith("/"):
-          full_uri = "http://%s%s" % (service.server, full_uri)
-        else:
-          full_uri = "http://%s/%s" % (service.server, full_uri)
-    else:
-      connection = httplib.HTTPConnection(server, port)
-      full_uri = partial_uri
-
-  return (connection, full_uri)
-
-
-def UseBasicAuth(service, username, password, for_proxy=False):
-  """Sets an Authenticaiton: Basic HTTP header containing plaintext.
-
-  Deprecated, use AtomService.use_basic_auth insread.
-  
-  The username and password are base64 encoded and added to an HTTP header
-  which will be included in each request. Note that your username and 
-  password are sent in plaintext. The auth header is added to the 
-  additional_headers dictionary in the service object.
-
-  Args:
-    service: atom.AtomService or a subclass which has an 
-        additional_headers dict as a member.
-    username: str
-    password: str
-  """
-  deprecation('calling deprecated function UseBasicAuth')
-  base_64_string = base64.encodestring('%s:%s' % (username, password))
-  base_64_string = base_64_string.strip()
-  if for_proxy:
-    header_name = 'Proxy-Authorization'
-  else:
-    header_name = 'Authorization'
-  service.additional_headers[header_name] = 'Basic %s' % (base_64_string,)
-
-
-def ProcessUrl(service, url, for_proxy=False):
-  """Processes a passed URL.  If the URL does not begin with https?, then
-  the default value for server is used
-
-  This method is deprecated, use atom.url.parse_url instead.
-  """
-  if not isinstance(url, atom.url.Url):
-    url = atom.url.parse_url(url)
-
-  server = url.host
-  ssl = False
-  port = 80
-
-  if not server:
-    if hasattr(service, 'server'):
-      server = service.server
-    else:
-      server = service
-    if not url.protocol and hasattr(service, 'ssl'):
-      ssl = service.ssl
-    if hasattr(service, 'port'):
-      port = service.port
-  else:
-    if url.protocol == 'https':
-      ssl = True
-    elif url.protocol == 'http':
-      ssl = False
-    if url.port:
-      port = int(url.port)
-    elif port == 80 and ssl:
-      port = 443
-
-  return (server, port, ssl, url.get_request_uri())
-
-def DictionaryToParamList(url_parameters, escape_params=True):
-  """Convert a dictionary of URL arguments into a URL parameter string.
-
-  This function is deprcated, use atom.url.Url instead.
-
-  Args:
-    url_parameters: The dictionaty of key-value pairs which will be converted
-                    into URL parameters. For example,
-                    {'dry-run': 'true', 'foo': 'bar'}
-                    will become ['dry-run=true', 'foo=bar'].
-
-  Returns:
-    A list which contains a string for each key-value pair. The strings are
-    ready to be incorporated into a URL by using '&'.join([] + parameter_list)
-  """
-  # Choose which function to use when modifying the query and parameters.
-  # Use quote_plus when escape_params is true.
-  transform_op = [str, urllib.quote_plus][bool(escape_params)]
-  # Create a list of tuples containing the escaped version of the
-  # parameter-value pairs.
-  parameter_tuples = [(transform_op(param), transform_op(value))
-                     for param, value in (url_parameters or {}).items()]
-  # Turn parameter-value tuples into a list of strings in the form
-  # 'PARAMETER=VALUE'.
-  return ['='.join(x) for x in parameter_tuples]
-
-
-def BuildUri(uri, url_params=None, escape_params=True):
-  """Converts a uri string and a collection of parameters into a URI.
-
-  This function is deprcated, use atom.url.Url instead.
-
-  Args:
-    uri: string
-    url_params: dict (optional)
-    escape_params: boolean (optional)
-    uri: string The start of the desired URI. This string can alrady contain
-         URL parameters. Examples: '/base/feeds/snippets', 
-         '/base/feeds/snippets?bq=digital+camera'
-    url_parameters: dict (optional) Additional URL parameters to be included
-                    in the query. These are translated into query arguments
-                    in the form '&dict_key=value&...'.
-                    Example: {'max-results': '250'} becomes &max-results=250
-    escape_params: boolean (optional) If false, the calling code has already
-                   ensured that the query will form a valid URL (all
-                   reserved characters have been escaped). If true, this
-                   method will escape the query and any URL parameters
-                   provided.
-
-  Returns:
-    string The URI consisting of the escaped URL parameters appended to the
-    initial uri string.
-  """
-  # Prepare URL parameters for inclusion into the GET request.
-  parameter_list = DictionaryToParamList(url_params, escape_params)
-
-  # Append the URL parameters to the URL.
-  if parameter_list:
-    if uri.find('?') != -1:
-      # If there are already URL parameters in the uri string, add the
-      # parameters after a new & character.
-      full_uri = '&'.join([uri] + parameter_list)
-    else:
-      # The uri string did not have any URL parameters (no ? character)
-      # so put a ? between the uri and URL parameters.
-      full_uri = '%s%s' % (uri, '?%s' % ('&'.join([] + parameter_list)))  
-  else:
-    full_uri = uri
-        
-  return full_uri
-
-  
-def HttpRequest(service, operation, data, uri, extra_headers=None, 
-    url_params=None, escape_params=True, content_type='application/atom+xml; charset=UTF-8'):
-  """Performs an HTTP call to the server, supports GET, POST, PUT, and DELETE.
-  
-  This method is deprecated, use atom.http.HttpClient.request instead.
-
-  Usage example, perform and HTTP GET on http://www.google.com/:
-    import atom.service
-    client = atom.service.AtomService()
-    http_response = client.Get('http://www.google.com/')
-  or you could set the client.server to 'www.google.com' and use the 
-  following:
-    client.server = 'www.google.com'
-    http_response = client.Get('/')
-
-  Args:
-    service: atom.AtomService object which contains some of the parameters 
-        needed to make the request. The following members are used to 
-        construct the HTTP call: server (str), additional_headers (dict), 
-        port (int), and ssl (bool).
-    operation: str The HTTP operation to be performed. This is usually one of
-        'GET', 'POST', 'PUT', or 'DELETE'
-    data: ElementTree, filestream, list of parts, or other object which can be 
-        converted to a string. 
-        Should be set to None when performing a GET or PUT.
-        If data is a file-like object which can be read, this method will read
-        a chunk of 100K bytes at a time and send them. 
-        If the data is a list of parts to be sent, each part will be evaluated
-        and sent.
-    uri: The beginning of the URL to which the request should be sent. 
-        Examples: '/', '/base/feeds/snippets', 
-        '/m8/feeds/contacts/default/base'
-    extra_headers: dict of strings. HTTP headers which should be sent
-        in the request. These headers are in addition to those stored in 
-        service.additional_headers.
-    url_params: dict of strings. Key value pairs to be added to the URL as
-        URL parameters. For example {'foo':'bar', 'test':'param'} will 
-        become ?foo=bar&test=param.
-    escape_params: bool default True. If true, the keys and values in 
-        url_params will be URL escaped when the form is constructed 
-        (Special characters converted to %XX form.)
-    content_type: str The MIME type for the data being sent. Defaults to
-        'application/atom+xml', this is only used if data is set.
-  """
-  deprecation('call to deprecated function HttpRequest')
-  full_uri = BuildUri(uri, url_params, escape_params)
-  (connection, full_uri) = PrepareConnection(service, full_uri)
-
-  if extra_headers is None:
-    extra_headers = {}
-
-  # Turn on debug mode if the debug member is set.
-  if service.debug:
-    connection.debuglevel = 1
-
-  connection.putrequest(operation, full_uri)
-
-  # If the list of headers does not include a Content-Length, attempt to 
-  # calculate it based on the data object.
-  if (data and not service.additional_headers.has_key('Content-Length') and 
-      not extra_headers.has_key('Content-Length')):
-    content_length = CalculateDataLength(data)
-    if content_length:
-      extra_headers['Content-Length'] = str(content_length)
-
-  if content_type:
-    extra_headers['Content-Type'] = content_type 
-
-  # Send the HTTP headers.
-  if isinstance(service.additional_headers, dict):
-    for header in service.additional_headers:
-      connection.putheader(header, service.additional_headers[header])
-  if isinstance(extra_headers, dict):
-    for header in extra_headers:
-      connection.putheader(header, extra_headers[header])
-  connection.endheaders()
-
-  # If there is data, send it in the request.
-  if data:
-    if isinstance(data, list):
-      for data_part in data:
-        __SendDataPart(data_part, connection)
-    else:
-      __SendDataPart(data, connection)
-
-  # Return the HTTP Response from the server.
-  return connection.getresponse()
-  
-
-def __SendDataPart(data, connection):
-  """This method is deprecated, use atom.http._send_data_part"""
-  deprecated('call to deprecated function __SendDataPart')
-  if isinstance(data, str):
-    #TODO add handling for unicode.
-    connection.send(data)
-    return
-  elif ElementTree.iselement(data):
-    connection.send(ElementTree.tostring(data))
-    return
-  # Check to see if data is a file-like object that has a read method.
-  elif hasattr(data, 'read'):
-    # Read the file and send it a chunk at a time.
-    while 1:
-      binarydata = data.read(100000)
-      if binarydata == '': break
-      connection.send(binarydata)
-    return
-  else:
-    # The data object was not a file.
-    # Try to convert to a string and send the data.
-    connection.send(str(data))
-    return
-
-
-def CalculateDataLength(data):
-  """Attempts to determine the length of the data to send. 
-  
-  This method will respond with a length only if the data is a string or
-  and ElementTree element.
-
-  Args:
-    data: object If this is not a string or ElementTree element this funtion
-        will return None.
-  """
-  if isinstance(data, str):
-    return len(data)
-  elif isinstance(data, list):
-    return None
-  elif ElementTree.iselement(data):
-    return len(ElementTree.tostring(data))
-  elif hasattr(data, 'read'):
-    # If this is a file-like object, don't try to guess the length.
-    return None
-  else:
-    return len(str(data))
-    
-
-def deprecation(message):
-  warnings.warn(message, DeprecationWarning, stacklevel=2)

atom/token_store.py

@@ -1,117 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""This module provides a TokenStore class which is designed to manage
-auth tokens required for different services.
-
-Each token is valid for a set of scopes which is the start of a URL. An HTTP
-client will use a token store to find a valid Authorization header to send
-in requests to the specified URL. If the HTTP client determines that a token
-has expired or been revoked, it can remove the token from the store so that
-it will not be used in future requests.
-"""
-
-
-__author__ = 'api.jscudder (Jeff Scudder)'
-
-
-import atom.http_interface
-import atom.url
-
-
-SCOPE_ALL = 'http'
-
-
-class TokenStore(object):
-  """Manages Authorization tokens which will be sent in HTTP headers."""
-  def __init__(self, scoped_tokens=None):
-    self._tokens = scoped_tokens or {}
-
-  def add_token(self, token):
-    """Adds a new token to the store (replaces tokens with the same scope).
-
-    Args:
-      token: A subclass of http_interface.GenericToken. The token object is 
-          responsible for adding the Authorization header to the HTTP request.
-          The scopes defined in the token are used to determine if the token
-          is valid for a requested scope when find_token is called.
-
-    Returns:
-      True if the token was added, False if the token was not added becase
-      no scopes were provided.
-    """
-    if not hasattr(token, 'scopes') or not token.scopes:
-      return False
-
-    for scope in token.scopes:
-      self._tokens[str(scope)] = token
-    return True  
-
-  def find_token(self, url):
-    """Selects an Authorization header token which can be used for the URL.
-
-    Args:
-      url: str or atom.url.Url or a list containing the same.
-          The URL which is going to be requested. All
-          tokens are examined to see if any scopes begin match the beginning
-          of the URL. The first match found is returned.
-
-    Returns:
-      The token object which should execute the HTTP request. If there was
-      no token for the url (the url did not begin with any of the token
-      scopes available), then the atom.http_interface.GenericToken will be 
-      returned because the GenericToken calls through to the http client
-      without adding an Authorization header.
-    """
-    if url is None:
-      return None
-    if isinstance(url, (str, unicode)):
-      url = atom.url.parse_url(url)
-    if url in self._tokens:
-      token = self._tokens[url]
-      if token.valid_for_scope(url):
-        return token
-      else:
-        del self._tokens[url]
-    for scope, token in self._tokens.iteritems():
-      if token.valid_for_scope(url):
-        return token
-    return atom.http_interface.GenericToken()
-
-  def remove_token(self, token):
-    """Removes the token from the token_store.
-
-    This method is used when a token is determined to be invalid. If the
-    token was found by find_token, but resulted in a 401 or 403 error stating
-    that the token was invlid, then the token should be removed to prevent
-    future use.
-
-    Returns:
-      True if a token was found and then removed from the token
-      store. False if the token was not in the TokenStore.
-    """
-    token_found = False
-    scopes_to_delete = []
-    for scope, stored_token in self._tokens.iteritems():
-      if stored_token == token:
-        scopes_to_delete.append(scope)
-        token_found = True
-    for scope in scopes_to_delete:
-      del self._tokens[scope]
-    return token_found
-
-  def remove_all_tokens(self):
-    self._tokens = {} 

atom/url.py

@@ -1,139 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-__author__ = 'api.jscudder (Jeff Scudder)'
-
-
-import urlparse
-import urllib
-
-
-DEFAULT_PROTOCOL = 'http'
-DEFAULT_PORT = 80
-
-
-def parse_url(url_string):
-  """Creates a Url object which corresponds to the URL string.
-  
-  This method can accept partial URLs, but it will leave missing
-  members of the Url unset.
-  """
-  parts = urlparse.urlparse(url_string)
-  url = Url()
-  if parts[0]:
-    url.protocol = parts[0]
-  if parts[1]:
-    host_parts = parts[1].split(':')
-    if host_parts[0]:
-      url.host = host_parts[0]
-    if len(host_parts) > 1:
-      url.port = host_parts[1]
-  if parts[2]:
-    url.path = parts[2]
-  if parts[4]:
-    param_pairs = parts[4].split('&')
-    for pair in param_pairs:
-      pair_parts = pair.split('=')
-      if len(pair_parts) > 1:
-        url.params[urllib.unquote_plus(pair_parts[0])] = (
-            urllib.unquote_plus(pair_parts[1]))
-      elif len(pair_parts) == 1:
-        url.params[urllib.unquote_plus(pair_parts[0])] = None
-  return url
-   
-class Url(object):
-  """Represents a URL and implements comparison logic.
-  
-  URL strings which are not identical can still be equivalent, so this object
-  provides a better interface for comparing and manipulating URLs than 
-  strings. URL parameters are represented as a dictionary of strings, and
-  defaults are used for the protocol (http) and port (80) if not provided.
-  """
-  def __init__(self, protocol=None, host=None, port=None, path=None, 
-               params=None):
-    self.protocol = protocol
-    self.host = host
-    self.port = port
-    self.path = path
-    self.params = params or {}
-
-  def to_string(self):
-    url_parts = ['', '', '', '', '', '']
-    if self.protocol:
-      url_parts[0] = self.protocol
-    if self.host:
-      if self.port:
-        url_parts[1] = ':'.join((self.host, str(self.port)))
-      else:
-        url_parts[1] = self.host
-    if self.path:
-      url_parts[2] = self.path
-    if self.params:
-      url_parts[4] = self.get_param_string()
-    return urlparse.urlunparse(url_parts)
-
-  def get_param_string(self):
-    param_pairs = []
-    for key, value in self.params.iteritems():
-      param_pairs.append('='.join((urllib.quote_plus(key), 
-          urllib.quote_plus(str(value)))))
-    return '&'.join(param_pairs)
-
-  def get_request_uri(self):
-    """Returns the path with the parameters escaped and appended."""
-    param_string = self.get_param_string()
-    if param_string:
-      return '?'.join([self.path, param_string])
-    else:
-      return self.path
-
-  def __cmp__(self, other):
-    if not isinstance(other, Url):
-      return cmp(self.to_string(), str(other))
-    difference = 0
-    # Compare the protocol
-    if self.protocol and other.protocol:
-      difference = cmp(self.protocol, other.protocol)
-    elif self.protocol and not other.protocol:
-      difference = cmp(self.protocol, DEFAULT_PROTOCOL)
-    elif not self.protocol and other.protocol:
-      difference = cmp(DEFAULT_PROTOCOL, other.protocol)
-    if difference != 0:
-      return difference
-    # Compare the host
-    difference = cmp(self.host, other.host)
-    if difference != 0:
-      return difference
-    # Compare the port
-    if self.port and other.port:
-      difference = cmp(self.port, other.port)
-    elif self.port and not other.port:
-      difference = cmp(self.port, DEFAULT_PORT)
-    elif not self.port and other.port:
-      difference = cmp(DEFAULT_PORT, other.port)
-    if difference != 0:
-      return difference
-    # Compare the path
-    difference = cmp(self.path, other.path)
-    if difference != 0:
-      return difference
-    # Compare the parameters
-    return cmp(self.params, other.params)
-
-  def __str__(self):
-    return self.to_string()
-    

build.bat

@@ -1,23 +0,0 @@
-rmdir /q /s gam
-rmdir /q /s gam-64
-rmdir /q /s python-src-%1
-rmdir /q /s build
-rmdir /q /s dist
-del /q /f gam-%1-python-src.zip
-del /q /f gam-%1-windows.zip
-del /q /f gam-%1-windows-x64.zip
-
-\python27-32\python.exe setup.py py2exe
-xcopy LICENSE gam\
-xcopy whatsnew.txt gam\
-xcopy cacert.pem gam\
-xcopy admin-settings-v1.json gam\
-del gam\w9xpopen.exe
-"%ProgramFiles(x86)%\7-Zip\7z.exe" a -tzip gam-%1-windows.zip gam\ -xr!.svn
-
-\python27\python.exe setup-64.py py2exe
-xcopy LICENSE gam-64\
-xcopy whatsnew.txt gam-64\
-xcopy cacert.pem gam-64\
-xcopy admin-settings-v1.json gam-64\
-"%ProgramFiles(x86)%\7-Zip\7z.exe" a -tzip gam-%1-windows-x64.zip gam-64\ -xr!.svn

gdata/__init__.py

@@ -1,835 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2006 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""Contains classes representing Google Data elements.
-
-  Extends Atom classes to add Google Data specific elements.
-"""
-
-
-__author__ = 'j.s@google.com (Jeffrey Scudder)'
-
-import os
-import atom
-try:
-  from xml.etree import cElementTree as ElementTree
-except ImportError:
-  try:
-    import cElementTree as ElementTree
-  except ImportError:
-    try:
-      from xml.etree import ElementTree
-    except ImportError:
-      from elementtree import ElementTree
-
-
-# XML namespaces which are often used in GData entities.
-GDATA_NAMESPACE = 'http://schemas.google.com/g/2005'
-GDATA_TEMPLATE = '{http://schemas.google.com/g/2005}%s'
-OPENSEARCH_NAMESPACE = 'http://a9.com/-/spec/opensearchrss/1.0/'
-OPENSEARCH_TEMPLATE = '{http://a9.com/-/spec/opensearchrss/1.0/}%s'
-BATCH_NAMESPACE = 'http://schemas.google.com/gdata/batch'
-GACL_NAMESPACE = 'http://schemas.google.com/acl/2007'
-GACL_TEMPLATE = '{http://schemas.google.com/acl/2007}%s'
-
-
-# Labels used in batch request entries to specify the desired CRUD operation.
-BATCH_INSERT = 'insert'
-BATCH_UPDATE = 'update'
-BATCH_DELETE = 'delete'
-BATCH_QUERY = 'query'
-
-class Error(Exception):
-  pass
-
-
-class MissingRequiredParameters(Error):
-  pass
-
-
-class MediaSource(object):
-  """GData Entries can refer to media sources, so this class provides a
-  place to store references to these objects along with some metadata.
-  """
-
-  def __init__(self, file_handle=None, content_type=None, content_length=None,
-      file_path=None, file_name=None):
-    """Creates an object of type MediaSource.
-
-    Args:
-      file_handle: A file handle pointing to the file to be encapsulated in the
-                   MediaSource
-      content_type: string The MIME type of the file. Required if a file_handle
-                    is given.
-      content_length: int The size of the file. Required if a file_handle is
-                      given.
-      file_path: string (optional) A full path name to the file. Used in
-                    place of a file_handle.
-      file_name: string The name of the file without any path information.
-                 Required if a file_handle is given.
-    """
-    self.file_handle = file_handle
-    self.content_type = content_type
-    self.content_length = content_length
-    self.file_name = file_name
-
-    if (file_handle is None and content_type is not None and
-        file_path is not None):
-      self.setFile(file_path, content_type)
-
-  def setFile(self, file_name, content_type):
-    """A helper function which can create a file handle from a given filename
-    and set the content type and length all at once.
-
-    Args:
-      file_name: string The path and file name to the file containing the media
-      content_type: string A MIME type representing the type of the media
-    """
-
-    self.file_handle = open(file_name, 'rb')
-    self.content_type = content_type
-    self.content_length = os.path.getsize(file_name)
-    self.file_name = os.path.basename(file_name)
-
-
-class LinkFinder(atom.LinkFinder):
-  """An "interface" providing methods to find link elements
-
-  GData Entry elements often contain multiple links which differ in the rel
-  attribute or content type. Often, developers are interested in a specific
-  type of link so this class provides methods to find specific classes of
-  links.
-
-  This class is used as a mixin in GData entries.
-  """
-
-  def GetSelfLink(self):
-    """Find the first link with rel set to 'self'
-
-    Returns:
-      An atom.Link or none if none of the links had rel equal to 'self'
-    """
-
-    for a_link in self.link:
-      if a_link.rel == 'self':
-        return a_link
-    return None
-
-  def GetEditLink(self):
-    for a_link in self.link:
-      if a_link.rel == 'edit':
-        return a_link
-    return None
-
-  def GetEditMediaLink(self):
-    """The Picasa API mistakenly returns media-edit rather than edit-media, but
-    this may change soon.
-    """
-    for a_link in self.link:
-      if a_link.rel == 'edit-media':
-        return a_link
-      if a_link.rel == 'media-edit':
-        return a_link
-    return None
-
-  def GetHtmlLink(self):
-    """Find the first link with rel of alternate and type of text/html
-
-    Returns:
-      An atom.Link or None if no links matched
-    """
-    for a_link in self.link:
-      if a_link.rel == 'alternate' and a_link.type == 'text/html':
-        return a_link
-    return None
-
-  def GetPostLink(self):
-    """Get a link containing the POST target URL.
-
-    The POST target URL is used to insert new entries.
-
-    Returns:
-      A link object with a rel matching the POST type.
-    """
-    for a_link in self.link:
-      if a_link.rel == 'http://schemas.google.com/g/2005#post':
-        return a_link
-    return None
-
-  def GetAclLink(self):
-    for a_link in self.link:
-      if a_link.rel == 'http://schemas.google.com/acl/2007#accessControlList':
-        return a_link
-    return None
-
-  def GetFeedLink(self):
-    for a_link in self.link:
-      if a_link.rel == 'http://schemas.google.com/g/2005#feed':
-        return a_link
-    return None
-
-  def GetNextLink(self):
-    for a_link in self.link:
-      if a_link.rel == 'next':
-        return a_link
-    return None
-
-  def GetPrevLink(self):
-    for a_link in self.link:
-      if a_link.rel == 'previous':
-        return a_link
-    return None
-
-
-class TotalResults(atom.AtomBase):
-  """opensearch:TotalResults for a GData feed"""
-
-  _tag = 'totalResults'
-  _namespace = OPENSEARCH_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-
-  def __init__(self, extension_elements=None,
-     extension_attributes=None, text=None):
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def TotalResultsFromString(xml_string):
-  return atom.CreateClassFromXMLString(TotalResults, xml_string)
-
-
-class StartIndex(atom.AtomBase):
-  """The opensearch:startIndex element in GData feed"""
-
-  _tag = 'startIndex'
-  _namespace = OPENSEARCH_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-
-  def __init__(self, extension_elements=None,
-      extension_attributes=None, text=None):
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def StartIndexFromString(xml_string):
-  return atom.CreateClassFromXMLString(StartIndex, xml_string)
-
-
-class ItemsPerPage(atom.AtomBase):
-  """The opensearch:itemsPerPage element in GData feed"""
-
-  _tag = 'itemsPerPage'
-  _namespace = OPENSEARCH_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-
-  def __init__(self, extension_elements=None,
-      extension_attributes=None, text=None):
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def ItemsPerPageFromString(xml_string):
-  return atom.CreateClassFromXMLString(ItemsPerPage, xml_string)
-
-
-class ExtendedProperty(atom.AtomBase):
-  """The Google Data extendedProperty element.
-
-  Used to store arbitrary key-value information specific to your
-  application. The value can either be a text string stored as an XML
-  attribute (.value), or an XML node (XmlBlob) as a child element.
-
-  This element is used in the Google Calendar data API and the Google
-  Contacts data API.
-  """
-
-  _tag = 'extendedProperty'
-  _namespace = GDATA_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _attributes['name'] = 'name'
-  _attributes['value'] = 'value'
-
-  def __init__(self, name=None, value=None, extension_elements=None,
-      extension_attributes=None, text=None):
-    self.name = name
-    self.value = value
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-  def GetXmlBlobExtensionElement(self):
-    """Returns the XML blob as an atom.ExtensionElement.
-
-    Returns:
-      An atom.ExtensionElement representing the blob's XML, or None if no
-      blob was set.
-    """
-    if len(self.extension_elements) < 1:
-      return None
-    else:
-      return self.extension_elements[0]
-
-  def GetXmlBlobString(self):
-    """Returns the XML blob as a string.
-
-    Returns:
-      A string containing the blob's XML, or None if no blob was set.
-    """
-    blob = self.GetXmlBlobExtensionElement()
-    if blob:
-      return blob.ToString()
-    return None
-
-  def SetXmlBlob(self, blob):
-    """Sets the contents of the extendedProperty to XML as a child node.
-
-    Since the extendedProperty is only allowed one child element as an XML
-    blob, setting the XML blob will erase any preexisting extension elements
-    in this object.
-
-    Args:
-      blob: str, ElementTree Element or atom.ExtensionElement representing
-            the XML blob stored in the extendedProperty.
-    """
-    # Erase any existing extension_elements, clears the child nodes from the
-    # extendedProperty.
-    self.extension_elements = []
-    if isinstance(blob, atom.ExtensionElement):
-      self.extension_elements.append(blob)
-    elif ElementTree.iselement(blob):
-      self.extension_elements.append(atom._ExtensionElementFromElementTree(
-          blob))
-    else:
-      self.extension_elements.append(atom.ExtensionElementFromString(blob))
-
-
-def ExtendedPropertyFromString(xml_string):
-  return atom.CreateClassFromXMLString(ExtendedProperty, xml_string)
-
-
-class GDataEntry(atom.Entry, LinkFinder):
-  """Extends Atom Entry to provide data processing"""
-
-  _tag = atom.Entry._tag
-  _namespace = atom.Entry._namespace
-  _children = atom.Entry._children.copy()
-  _attributes = atom.Entry._attributes.copy()
-
-  def __GetId(self):
-    return self.__id
-
-  # This method was created to strip the unwanted whitespace from the id's
-  # text node.
-  def __SetId(self, id):
-    self.__id = id
-    if id is not None and id.text is not None:
-      self.__id.text = id.text.strip()
-
-  id = property(__GetId, __SetId)
-
-  def IsMedia(self):
-    """Determines whether or not an entry is a GData Media entry.
-    """
-    if (self.GetEditMediaLink()):
-      return True
-    else:
-      return False
-
-  def GetMediaURL(self):
-    """Returns the URL to the media content, if the entry is a media entry.
-    Otherwise returns None.
-    """
-    if not self.IsMedia():
-      return None
-    else:
-      return self.content.src
-
-
-def GDataEntryFromString(xml_string):
-  """Creates a new GDataEntry instance given a string of XML."""
-  return atom.CreateClassFromXMLString(GDataEntry, xml_string)
-
-
-class GDataFeed(atom.Feed, LinkFinder):
-  """A Feed from a GData service"""
-
-  _tag = 'feed'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = atom.Feed._children.copy()
-  _attributes = atom.Feed._attributes.copy()
-  _children['{%s}totalResults' % OPENSEARCH_NAMESPACE] = ('total_results',
-                                                          TotalResults)
-  _children['{%s}startIndex' % OPENSEARCH_NAMESPACE] = ('start_index',
-                                                        StartIndex)
-  _children['{%s}itemsPerPage' % OPENSEARCH_NAMESPACE] = ('items_per_page',
-                                                          ItemsPerPage)
-               # Add a conversion rule for atom:entry to make it into a GData
-               # Entry.
-  _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [GDataEntry])
-
-  def __GetId(self):
-    return self.__id
-
-  def __SetId(self, id):
-    self.__id = id
-    if id is not None and id.text is not None:
-      self.__id.text = id.text.strip()
-
-  id = property(__GetId, __SetId)
-
-  def __GetGenerator(self):
-    return self.__generator
-
-  def __SetGenerator(self, generator):
-    self.__generator = generator
-    if generator is not None:
-      self.__generator.text = generator.text.strip()
-
-  generator = property(__GetGenerator, __SetGenerator)
-
-  def __init__(self, author=None, category=None, contributor=None,
-      generator=None, icon=None, atom_id=None, link=None, logo=None,
-      rights=None, subtitle=None, title=None, updated=None, entry=None,
-      total_results=None, start_index=None, items_per_page=None,
-      extension_elements=None, extension_attributes=None, text=None):
-    """Constructor for Source
-
-    Args:
-      author: list (optional) A list of Author instances which belong to this
-          class.
-      category: list (optional) A list of Category instances
-      contributor: list (optional) A list on Contributor instances
-      generator: Generator (optional)
-      icon: Icon (optional)
-      id: Id (optional) The entry's Id element
-      link: list (optional) A list of Link instances
-      logo: Logo (optional)
-      rights: Rights (optional) The entry's Rights element
-      subtitle: Subtitle (optional) The entry's subtitle element
-      title: Title (optional) the entry's title element
-      updated: Updated (optional) the entry's updated element
-      entry: list (optional) A list of the Entry instances contained in the
-          feed.
-      text: String (optional) The text contents of the element. This is the
-          contents of the Entry's XML text node.
-          (Example: <foo>This is the text</foo>)
-      extension_elements: list (optional) A list of ExtensionElement instances
-          which are children of this element.
-      extension_attributes: dict (optional) A dictionary of strings which are
-          the values for additional XML attributes of this element.
-    """
-
-    self.author = author or []
-    self.category = category or []
-    self.contributor = contributor or []
-    self.generator = generator
-    self.icon = icon
-    self.id = atom_id
-    self.link = link or []
-    self.logo = logo
-    self.rights = rights
-    self.subtitle = subtitle
-    self.title = title
-    self.updated = updated
-    self.entry = entry or []
-    self.total_results = total_results
-    self.start_index = start_index
-    self.items_per_page = items_per_page
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def GDataFeedFromString(xml_string):
-  return atom.CreateClassFromXMLString(GDataFeed, xml_string)
-
-
-class BatchId(atom.AtomBase):
-  _tag = 'id'
-  _namespace = BATCH_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-
-
-def BatchIdFromString(xml_string):
-  return atom.CreateClassFromXMLString(BatchId, xml_string)
-
-
-class BatchOperation(atom.AtomBase):
-  _tag = 'operation'
-  _namespace = BATCH_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _attributes['type'] = 'type'
-
-  def __init__(self, op_type=None, extension_elements=None,
-               extension_attributes=None,
-               text=None):
-    self.type = op_type
-    atom.AtomBase.__init__(self,
-                           extension_elements=extension_elements,
-                           extension_attributes=extension_attributes,
-                           text=text)
-
-
-def BatchOperationFromString(xml_string):
-  return atom.CreateClassFromXMLString(BatchOperation, xml_string)
-
-
-class BatchStatus(atom.AtomBase):
-  """The batch:status element present in a batch response entry.
-
-  A status element contains the code (HTTP response code) and
-  reason as elements. In a single request these fields would
-  be part of the HTTP response, but in a batch request each
-  Entry operation has a corresponding Entry in the response
-  feed which includes status information.
-
-  See http://code.google.com/apis/gdata/batch.html#Handling_Errors
-  """
-
-  _tag = 'status'
-  _namespace = BATCH_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _attributes['code'] = 'code'
-  _attributes['reason'] = 'reason'
-  _attributes['content-type'] = 'content_type'
-
-  def __init__(self, code=None, reason=None, content_type=None,
-               extension_elements=None, extension_attributes=None, text=None):
-    self.code = code
-    self.reason = reason
-    self.content_type = content_type
-    atom.AtomBase.__init__(self, extension_elements=extension_elements,
-                           extension_attributes=extension_attributes,
-                           text=text)
-
-
-def BatchStatusFromString(xml_string):
-  return atom.CreateClassFromXMLString(BatchStatus, xml_string)
-
-
-class BatchEntry(GDataEntry):
-  """An atom:entry for use in batch requests.
-
-  The BatchEntry contains additional members to specify the operation to be
-  performed on this entry and a batch ID so that the server can reference
-  individual operations in the response feed. For more information, see:
-  http://code.google.com/apis/gdata/batch.html
-  """
-
-  _tag = GDataEntry._tag
-  _namespace = GDataEntry._namespace
-  _children = GDataEntry._children.copy()
-  _children['{%s}operation' % BATCH_NAMESPACE] = ('batch_operation', BatchOperation)
-  _children['{%s}id' % BATCH_NAMESPACE] = ('batch_id', BatchId)
-  _children['{%s}status' % BATCH_NAMESPACE] = ('batch_status', BatchStatus)
-  _attributes = GDataEntry._attributes.copy()
-
-  def __init__(self, author=None, category=None, content=None,
-      contributor=None, atom_id=None, link=None, published=None, rights=None,
-      source=None, summary=None, control=None, title=None, updated=None,
-      batch_operation=None, batch_id=None, batch_status=None,
-      extension_elements=None, extension_attributes=None, text=None):
-    self.batch_operation = batch_operation
-    self.batch_id = batch_id
-    self.batch_status = batch_status
-    GDataEntry.__init__(self, author=author, category=category,
-        content=content, contributor=contributor, atom_id=atom_id, link=link,
-        published=published, rights=rights, source=source, summary=summary,
-        control=control, title=title, updated=updated,
-        extension_elements=extension_elements,
-        extension_attributes=extension_attributes, text=text)
-
-
-def BatchEntryFromString(xml_string):
-  return atom.CreateClassFromXMLString(BatchEntry, xml_string)
-
-
-class BatchInterrupted(atom.AtomBase):
-  """The batch:interrupted element sent if batch request was interrupted.
-
-  Only appears in a feed if some of the batch entries could not be processed.
-  See: http://code.google.com/apis/gdata/batch.html#Handling_Errors
-  """
-
-  _tag = 'interrupted'
-  _namespace = BATCH_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _attributes['reason'] = 'reason'
-  _attributes['success'] = 'success'
-  _attributes['failures'] = 'failures'
-  _attributes['parsed'] = 'parsed'
-
-  def __init__(self, reason=None, success=None, failures=None, parsed=None,
-               extension_elements=None, extension_attributes=None, text=None):
-    self.reason = reason
-    self.success = success
-    self.failures = failures
-    self.parsed = parsed
-    atom.AtomBase.__init__(self, extension_elements=extension_elements,
-                           extension_attributes=extension_attributes,
-                           text=text)
-
-
-def BatchInterruptedFromString(xml_string):
-  return atom.CreateClassFromXMLString(BatchInterrupted, xml_string)
-
-
-class BatchFeed(GDataFeed):
-  """A feed containing a list of batch request entries."""
-
-  _tag = GDataFeed._tag
-  _namespace = GDataFeed._namespace
-  _children = GDataFeed._children.copy()
-  _attributes = GDataFeed._attributes.copy()
-  _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [BatchEntry])
-  _children['{%s}interrupted' % BATCH_NAMESPACE] = ('interrupted', BatchInterrupted)
-
-  def __init__(self, author=None, category=None, contributor=None,
-      generator=None, icon=None, atom_id=None, link=None, logo=None,
-      rights=None, subtitle=None, title=None, updated=None, entry=None,
-      total_results=None, start_index=None, items_per_page=None,
-      interrupted=None,
-      extension_elements=None, extension_attributes=None, text=None):
-    self.interrupted = interrupted
-    GDataFeed.__init__(self, author=author, category=category,
-                       contributor=contributor, generator=generator,
-                       icon=icon, atom_id=atom_id, link=link,
-                       logo=logo, rights=rights, subtitle=subtitle,
-                       title=title, updated=updated, entry=entry,
-                       total_results=total_results, start_index=start_index,
-                       items_per_page=items_per_page,
-                       extension_elements=extension_elements,
-                       extension_attributes=extension_attributes,
-                       text=text)
-
-  def AddBatchEntry(self, entry=None, id_url_string=None,
-                     batch_id_string=None, operation_string=None):
-    """Logic for populating members of a BatchEntry and adding to the feed.
-
-
-    If the entry is not a BatchEntry, it is converted to a BatchEntry so
-    that the batch specific members will be present.
-
-    The id_url_string can be used in place of an entry if the batch operation
-    applies to a URL. For example query and delete operations require just
-    the URL of an entry, no body is sent in the HTTP request. If an
-    id_url_string is sent instead of an entry, a BatchEntry is created and
-    added to the feed.
-
-    This method also assigns the desired batch id to the entry so that it
-    can be referenced in the server's response. If the batch_id_string is
-    None, this method will assign a batch_id to be the index at which this
-    entry will be in the feed's entry list.
-
-    Args:
-      entry: BatchEntry, atom.Entry, or another Entry flavor (optional) The
-          entry which will be sent to the server as part of the batch request.
-          The item must have a valid atom id so that the server knows which
-          entry this request references.
-      id_url_string: str (optional) The URL of the entry to be acted on. You
-          can find this URL in the text member of the atom id for an entry.
-          If an entry is not sent, this id will be used to construct a new
-          BatchEntry which will be added to the request feed.
-      batch_id_string: str (optional) The batch ID to be used to reference
-          this batch operation in the results feed. If this parameter is None,
-          the current length of the feed's entry array will be used as a
-          count. Note that batch_ids should either always be specified or
-          never, mixing could potentially result in duplicate batch ids.
-      operation_string: str (optional) The desired batch operation which will
-          set the batch_operation.type member of the entry. Options are
-          'insert', 'update', 'delete', and 'query'
-
-    Raises:
-      MissingRequiredParameters: Raised if neither an id_ url_string nor an
-          entry are provided in the request.
-
-    Returns:
-      The added entry.
-    """
-    if entry is None and id_url_string is None:
-      raise MissingRequiredParameters('supply either an entry or URL string')
-    if entry is None and id_url_string is not None:
-      entry = BatchEntry(atom_id=atom.Id(text=id_url_string))
-    # TODO: handle cases in which the entry lacks batch_... members.
-    #if not isinstance(entry, BatchEntry):
-      # Convert the entry to a batch entry.
-    if batch_id_string is not None:
-      entry.batch_id = BatchId(text=batch_id_string)
-    elif entry.batch_id is None or entry.batch_id.text is None:
-      entry.batch_id = BatchId(text=str(len(self.entry)))
-    if operation_string is not None:
-      entry.batch_operation = BatchOperation(op_type=operation_string)
-    self.entry.append(entry)
-    return entry
-
-  def AddInsert(self, entry, batch_id_string=None):
-    """Add an insert request to the operations in this batch request feed.
-
-    If the entry doesn't yet have an operation or a batch id, these will
-    be set to the insert operation and a batch_id specified as a parameter.
-
-    Args:
-      entry: BatchEntry The entry which will be sent in the batch feed as an
-          insert request.
-      batch_id_string: str (optional) The batch ID to be used to reference
-          this batch operation in the results feed. If this parameter is None,
-          the current length of the feed's entry array will be used as a
-          count. Note that batch_ids should either always be specified or
-          never, mixing could potentially result in duplicate batch ids.
-    """
-    entry = self.AddBatchEntry(entry=entry, batch_id_string=batch_id_string,
-                               operation_string=BATCH_INSERT)
-
-  def AddUpdate(self, entry, batch_id_string=None):
-    """Add an update request to the list of batch operations in this feed.
-
-    Sets the operation type of the entry to insert if it is not already set
-    and assigns the desired batch id to the entry so that it can be
-    referenced in the server's response.
-
-    Args:
-      entry: BatchEntry The entry which will be sent to the server as an
-          update (HTTP PUT) request. The item must have a valid atom id
-          so that the server knows which entry to replace.
-      batch_id_string: str (optional) The batch ID to be used to reference
-          this batch operation in the results feed. If this parameter is None,
-          the current length of the feed's entry array will be used as a
-          count. See also comments for AddInsert.
-    """
-    entry = self.AddBatchEntry(entry=entry, batch_id_string=batch_id_string,
-                               operation_string=BATCH_UPDATE)
-
-  def AddDelete(self, url_string=None, entry=None, batch_id_string=None):
-    """Adds a delete request to the batch request feed.
-
-    This method takes either the url_string which is the atom id of the item
-    to be deleted, or the entry itself. The atom id of the entry must be
-    present so that the server knows which entry should be deleted.
-
-    Args:
-      url_string: str (optional) The URL of the entry to be deleted. You can
-         find this URL in the text member of the atom id for an entry.
-      entry: BatchEntry (optional) The entry to be deleted.
-      batch_id_string: str (optional)
-
-    Raises:
-      MissingRequiredParameters: Raised if neither a url_string nor an entry
-          are provided in the request.
-    """
-    entry = self.AddBatchEntry(entry=entry, id_url_string=url_string,
-                               batch_id_string=batch_id_string,
-                               operation_string=BATCH_DELETE)
-
-  def AddQuery(self, url_string=None, entry=None, batch_id_string=None):
-    """Adds a query request to the batch request feed.
-
-    This method takes either the url_string which is the query URL
-    whose results will be added to the result feed. The query URL will
-    be encapsulated in a BatchEntry, and you may pass in the BatchEntry
-    with a query URL instead of sending a url_string.
-
-    Args:
-      url_string: str (optional)
-      entry: BatchEntry (optional)
-      batch_id_string: str (optional)
-
-    Raises:
-      MissingRequiredParameters
-    """
-    entry = self.AddBatchEntry(entry=entry, id_url_string=url_string,
-                               batch_id_string=batch_id_string,
-                               operation_string=BATCH_QUERY)
-
-  def GetBatchLink(self):
-    for link in self.link:
-      if link.rel == 'http://schemas.google.com/g/2005#batch':
-        return link
-    return None
-
-
-def BatchFeedFromString(xml_string):
-  return atom.CreateClassFromXMLString(BatchFeed, xml_string)
-
-
-class EntryLink(atom.AtomBase):
-  """The gd:entryLink element"""
-
-  _tag = 'entryLink'
-  _namespace = GDATA_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  # The entry used to be an atom.Entry, now it is a GDataEntry.
-  _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', GDataEntry)
-  _attributes['rel'] = 'rel'
-  _attributes['readOnly'] = 'read_only'
-  _attributes['href'] = 'href'
-
-  def __init__(self, href=None, read_only=None, rel=None,
-      entry=None, extension_elements=None,
-      extension_attributes=None, text=None):
-    self.href = href
-    self.read_only = read_only
-    self.rel = rel
-    self.entry = entry
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def EntryLinkFromString(xml_string):
-  return atom.CreateClassFromXMLString(EntryLink, xml_string)
-
-
-class FeedLink(atom.AtomBase):
-  """The gd:feedLink element"""
-
-  _tag = 'feedLink'
-  _namespace = GDATA_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _children['{%s}feed' % atom.ATOM_NAMESPACE] = ('feed', GDataFeed)
-  _attributes['rel'] = 'rel'
-  _attributes['readOnly'] = 'read_only'
-  _attributes['countHint'] = 'count_hint'
-  _attributes['href'] = 'href'
-
-  def __init__(self, count_hint=None, href=None, read_only=None, rel=None,
-      feed=None, extension_elements=None, extension_attributes=None,
-      text=None):
-    self.count_hint = count_hint
-    self.href = href
-    self.read_only = read_only
-    self.rel = rel
-    self.feed = feed
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def FeedLinkFromString(xml_string):
-  return atom.CreateClassFromXMLString(FeedLink, xml_string)

gdata/alt/__init__.py

@@ -1,20 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""This package's modules adapt the gdata library to run in other environments
-
-The first example is the appengine module which contains functions and
-classes which modify a GDataService object to run on Google App Engine.
-"""

gdata/alt/app_engine.py

@@ -1,101 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2009 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""Provides functions to persist serialized auth tokens in the datastore.
-
-The get_token and set_token functions should be used in conjunction with
-gdata.gauth's token_from_blob and token_to_blob to allow auth token objects
-to be reused across requests. It is up to your own code to ensure that the
-token key's are unique.
-"""
-
-__author__ = 'j.s@google.com (Jeff Scudder)'
-
-
-from google.appengine.ext import db
-from google.appengine.api import memcache
-
-
-class Token(db.Model):
-  """Datastore Model which stores a serialized auth token."""
-  t = db.BlobProperty()
-
-
-def get_token(unique_key):
-  """Searches for a stored token with the desired key.
-
-  Checks memcache and then the datastore if required.
-
-  Args:
-    unique_key: str which uniquely identifies the desired auth token.
-
-  Returns:
-    A string encoding the auth token data. Use gdata.gauth.token_from_blob to
-    convert back into a usable token object. None if the token was not found
-    in memcache or the datastore.
-  """
-  token_string = memcache.get(unique_key)
-  if token_string is None:
-    # The token wasn't in memcache, so look in the datastore.
-    token = Token.get_by_key_name(unique_key)
-    if token is None:
-      return None
-    return token.t
-  return token_string
-
-
-def set_token(unique_key, token_str):
-  """Saves the serialized auth token in the datastore.
-
-  The token is also stored in memcache to speed up retrieval on a cache hit.
-
-  Args:
-    unique_key: The unique name for this token as a string. It is up to your
-        code to ensure that this token value is unique in your application.
-        Previous values will be silently overwitten.
-    token_str: A serialized auth token as a string. I expect that this string
-        will be generated by gdata.gauth.token_to_blob.
-
-  Returns:
-    True if the token was stored sucessfully, False if the token could not be
-    safely cached (if an old value could not be cleared). If the token was
-    set in memcache, but not in the datastore, this function will return None.
-    However, in that situation an exception will likely be raised.
-
-  Raises:
-    Datastore exceptions may be raised from the App Engine SDK in the event of
-    failure.
-  """
-  # First try to save in memcache.
-  result = memcache.set(unique_key, token_str)
-  # If memcache fails to save the value, clear the cached value.
-  if not result:
-    result = memcache.delete(unique_key)
-    # If we could not clear the cached value for this token, refuse to save.
-    if result == 0:
-      return False
-  # Save to the datastore.
-  if Token(key_name=unique_key, t=token_str).put():
-    return True
-  return None
-
-
-def delete_token(unique_key):
-  # Clear from memcache.
-  memcache.delete(unique_key)
-  # Clear from the datastore.
-  Token(key_name=unique_key).delete()

gdata/alt/appengine.py

@@ -1,321 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-"""Provides HTTP functions for gdata.service to use on Google App Engine
-
-AppEngineHttpClient: Provides an HTTP request method which uses App Engine's
-   urlfetch API. Set the http_client member of a GDataService object to an
-   instance of an AppEngineHttpClient to allow the gdata library to run on
-   Google App Engine.
-
-run_on_appengine: Function which will modify an existing GDataService object
-   to allow it to run on App Engine. It works by creating a new instance of
-   the AppEngineHttpClient and replacing the GDataService object's
-   http_client.
-"""
-
-
-__author__ = 'api.jscudder (Jeff Scudder)'
-
-
-import StringIO
-import pickle
-import atom.http_interface
-import atom.token_store
-from google.appengine.api import urlfetch
-from google.appengine.ext import db
-from google.appengine.api import users
-from google.appengine.api import memcache
-
-
-def run_on_appengine(gdata_service, store_tokens=True, 
-    single_user_mode=False, deadline=None):
-  """Modifies a GDataService object to allow it to run on App Engine.
-
-  Args:
-    gdata_service: An instance of AtomService, GDataService, or any
-        of their subclasses which has an http_client member and a 
-        token_store member.
-    store_tokens: Boolean, defaults to True. If True, the gdata_service
-                  will attempt to add each token to it's token_store when
-                  SetClientLoginToken or SetAuthSubToken is called. If False
-                  the tokens will not automatically be added to the 
-                  token_store.
-    single_user_mode: Boolean, defaults to False. If True, the current_token
-                      member of gdata_service will be set when 
-                      SetClientLoginToken or SetAuthTubToken is called. If set
-                      to True, the current_token is set in the gdata_service
-                      and anyone who accesses the object will use the same 
-                      token. 
-                      
-                      Note: If store_tokens is set to False and 
-                      single_user_mode is set to False, all tokens will be 
-                      ignored, since the library assumes: the tokens should not
-                      be stored in the datastore and they should not be stored
-                      in the gdata_service object. This will make it 
-                      impossible to make requests which require authorization.
-    deadline: int (optional) The number of seconds to wait for a response
-              before timing out on the HTTP request. If no deadline is
-              specified, the deafault deadline for HTTP requests from App
-              Engine is used. The maximum is currently 10 (for 10 seconds).
-              The default deadline for App Engine is 5 seconds.
-  """
-  gdata_service.http_client = AppEngineHttpClient(deadline=deadline)
-  gdata_service.token_store = AppEngineTokenStore()
-  gdata_service.auto_store_tokens = store_tokens
-  gdata_service.auto_set_current_token = single_user_mode
-  return gdata_service
-
-
-class AppEngineHttpClient(atom.http_interface.GenericHttpClient):
-  def __init__(self, headers=None, deadline=None):
-    self.debug = False
-    self.headers = headers or {}
-    self.deadline = deadline
-
-  def request(self, operation, url, data=None, headers=None):
-    """Performs an HTTP call to the server, supports GET, POST, PUT, and
-    DELETE.
-
-    Usage example, perform and HTTP GET on http://www.google.com/:
-      import atom.http
-      client = atom.http.HttpClient()
-      http_response = client.request('GET', 'http://www.google.com/')
-
-    Args:
-      operation: str The HTTP operation to be performed. This is usually one
-          of 'GET', 'POST', 'PUT', or 'DELETE'
-      data: filestream, list of parts, or other object which can be converted
-          to a string. Should be set to None when performing a GET or DELETE.
-          If data is a file-like object which can be read, this method will
-          read a chunk of 100K bytes at a time and send them.
-          If the data is a list of parts to be sent, each part will be
-          evaluated and sent.
-      url: The full URL to which the request should be sent. Can be a string
-          or atom.url.Url.
-      headers: dict of strings. HTTP headers which should be sent
-          in the request.
-    """
-    all_headers = self.headers.copy()
-    if headers:
-      all_headers.update(headers)
-
-    # Construct the full payload.
-    # Assume that data is None or a string.
-    data_str = data
-    if data:
-      if isinstance(data, list):
-        # If data is a list of different objects, convert them all to strings
-        # and join them together.
-        converted_parts = [_convert_data_part(x) for x in data]
-        data_str = ''.join(converted_parts)
-      else:
-        data_str = _convert_data_part(data)
-
-    # If the list of headers does not include a Content-Length, attempt to
-    # calculate it based on the data object.
-    if data and 'Content-Length' not in all_headers:
-      all_headers['Content-Length'] = str(len(data_str))
-
-    # Set the content type to the default value if none was set.
-    if 'Content-Type' not in all_headers:
-      all_headers['Content-Type'] = 'application/atom+xml'
-
-    # Lookup the urlfetch operation which corresponds to the desired HTTP verb.
-    if operation == 'GET':
-      method = urlfetch.GET
-    elif operation == 'POST':
-      method = urlfetch.POST
-    elif operation == 'PUT':
-      method = urlfetch.PUT
-    elif operation == 'DELETE':
-      method = urlfetch.DELETE
-    else:
-      method = None
-    if self.deadline is None:
-      return HttpResponse(urlfetch.Fetch(url=str(url), payload=data_str,
-          method=method, headers=all_headers, follow_redirects=False))
-    return HttpResponse(urlfetch.Fetch(url=str(url), payload=data_str,
-        method=method, headers=all_headers, follow_redirects=False,
-        deadline=self.deadline))
-
-
-def _convert_data_part(data):
-  if not data or isinstance(data, str):
-    return data
-  elif hasattr(data, 'read'):
-    # data is a file like object, so read it completely.
-    return data.read()
-  # The data object was not a file.
-  # Try to convert to a string and send the data.
-  return str(data)
-
-
-class HttpResponse(object):
-  """Translates a urlfetch resoinse to look like an hhtplib resoinse.
-
-  Used to allow the resoinse from HttpRequest to be usable by gdata.service
-  methods.
-  """
-
-  def __init__(self, urlfetch_response):
-    self.body = StringIO.StringIO(urlfetch_response.content)
-    self.headers = urlfetch_response.headers
-    self.status = urlfetch_response.status_code
-    self.reason = ''
-
-  def read(self, length=None):
-    if not length:
-      return self.body.read()
-    else:
-      return self.body.read(length)
-
-  def getheader(self, name):
-    if not self.headers.has_key(name):
-      return self.headers[name.lower()]
-    return self.headers[name]
-
-
-class TokenCollection(db.Model):
-  """Datastore Model which associates auth tokens with the current user."""
-  user = db.UserProperty()
-  pickled_tokens = db.BlobProperty()
-
-
-class AppEngineTokenStore(atom.token_store.TokenStore):
-  """Stores the user's auth tokens in the App Engine datastore.
-
-  Tokens are only written to the datastore if a user is signed in (if 
-  users.get_current_user() returns a user object).
-  """
-  def __init__(self):
-    self.user = None
-
-  def add_token(self, token):
-    """Associates the token with the current user and stores it.
-    
-    If there is no current user, the token will not be stored.
-
-    Returns:
-      False if the token was not stored. 
-    """
-    tokens = load_auth_tokens(self.user)
-    if not hasattr(token, 'scopes') or not token.scopes:
-      return False
-    for scope in token.scopes:
-      tokens[str(scope)] = token
-    key = save_auth_tokens(tokens, self.user)
-    if key:
-      return True
-    return False
-
-  def find_token(self, url):
-    """Searches the current user's collection of token for a token which can
-    be used for a request to the url.
-
-    Returns:
-      The stored token which belongs to the current user and is valid for the
-      desired URL. If there is no current user, or there is no valid user 
-      token in the datastore, a atom.http_interface.GenericToken is returned.
-    """
-    if url is None:
-      return None
-    if isinstance(url, (str, unicode)):
-      url = atom.url.parse_url(url)
-    tokens = load_auth_tokens(self.user)
-    if url in tokens:
-      token = tokens[url]
-      if token.valid_for_scope(url):
-        return token
-      else:
-        del tokens[url]
-        save_auth_tokens(tokens, self.user)
-    for scope, token in tokens.iteritems():
-      if token.valid_for_scope(url):
-        return token
-    return atom.http_interface.GenericToken()
-
-  def remove_token(self, token):
-    """Removes the token from the current user's collection in the datastore.
-    
-    Returns:
-      False if the token was not removed, this could be because the token was
-      not in the datastore, or because there is no current user.
-    """
-    token_found = False
-    scopes_to_delete = []
-    tokens = load_auth_tokens(self.user)
-    for scope, stored_token in tokens.iteritems():
-      if stored_token == token:
-        scopes_to_delete.append(scope)
-        token_found = True
-    for scope in scopes_to_delete:
-      del tokens[scope]
-    if token_found:
-      save_auth_tokens(tokens, self.user)
-    return token_found
-
-  def remove_all_tokens(self):
-    """Removes all of the current user's tokens from the datastore."""
-    save_auth_tokens({}, self.user)
-
-
-def save_auth_tokens(token_dict, user=None):
-  """Associates the tokens with the current user and writes to the datastore.
-  
-  If there us no current user, the tokens are not written and this function
-  returns None.
-
-  Returns:
-    The key of the datastore entity containing the user's tokens, or None if
-    there was no current user.
-  """
-  if user is None:
-    user = users.get_current_user()
-  if user is None:
-    return None
-  memcache.set('gdata_pickled_tokens:%s' % user, pickle.dumps(token_dict))
-  user_tokens = TokenCollection.all().filter('user =', user).get()
-  if user_tokens:
-    user_tokens.pickled_tokens = pickle.dumps(token_dict)
-    return user_tokens.put()
-  else:
-    user_tokens = TokenCollection(
-        user=user, 
-        pickled_tokens=pickle.dumps(token_dict))
-    return user_tokens.put()
-     
-
-def load_auth_tokens(user=None):
-  """Reads a dictionary of the current user's tokens from the datastore.
-  
-  If there is no current user (a user is not signed in to the app) or the user
-  does not have any tokens, an empty dictionary is returned.
-  """
-  if user is None:
-    user = users.get_current_user()
-  if user is None:
-    return {}
-  pickled_tokens = memcache.get('gdata_pickled_tokens:%s' % user)
-  if pickled_tokens:
-    return pickle.loads(pickled_tokens)
-  user_tokens = TokenCollection.all().filter('user =', user).get()
-  if user_tokens:
-    memcache.set('gdata_pickled_tokens:%s' % user, user_tokens.pickled_tokens)
-    return pickle.loads(user_tokens.pickled_tokens)
-  return {}
-

gdata/apps/__init__.py

@@ -1,526 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2007 SIOS Technology, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Contains objects used with Google Apps."""
-
-__author__ = 'tmatsuo@sios.com (Takashi MATSUO)'
-
-
-import atom
-import gdata
-
-
-# XML namespaces which are often used in Google Apps entity.
-APPS_NAMESPACE = 'http://schemas.google.com/apps/2006'
-APPS_TEMPLATE = '{http://schemas.google.com/apps/2006}%s'
-
-
-class EmailList(atom.AtomBase):
-  """The Google Apps EmailList element"""
-  
-  _tag = 'emailList'
-  _namespace = APPS_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _attributes['name'] = 'name'
-
-  def __init__(self, name=None, extension_elements=None,
-               extension_attributes=None, text=None):
-    self.name = name
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-def EmailListFromString(xml_string):
-  return atom.CreateClassFromXMLString(EmailList, xml_string)
-  
-
-class Who(atom.AtomBase):
-  """The Google Apps Who element"""
-  
-  _tag = 'who'
-  _namespace = gdata.GDATA_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _attributes['rel'] = 'rel'
-  _attributes['email'] = 'email'
-
-  def __init__(self, rel=None, email=None, extension_elements=None,
-               extension_attributes=None, text=None):
-    self.rel = rel
-    self.email = email
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-def WhoFromString(xml_string):
-  return atom.CreateClassFromXMLString(Who, xml_string)
-  
-
-class Login(atom.AtomBase):
-  """The Google Apps Login element"""
-  
-  _tag = 'login'
-  _namespace = APPS_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _attributes['userName'] = 'user_name'
-  _attributes['password'] = 'password'
-  _attributes['suspended'] = 'suspended'
-  _attributes['admin'] = 'admin'
-  _attributes['changePasswordAtNextLogin'] = 'change_password'
-  _attributes['agreedToTerms'] = 'agreed_to_terms'
-  _attributes['ipWhitelisted'] = 'ip_whitelisted'
-  _attributes['hashFunctionName'] = 'hash_function_name'
-
-  def __init__(self, user_name=None, password=None, suspended=None,
-               ip_whitelisted=None, hash_function_name=None, 
-               admin=None, change_password=None, agreed_to_terms=None, 
-               extension_elements=None, extension_attributes=None, 
-               text=None):
-    self.user_name = user_name
-    self.password = password
-    self.suspended = suspended
-    self.admin = admin
-    self.change_password = change_password
-    self.agreed_to_terms = agreed_to_terms
-    self.ip_whitelisted = ip_whitelisted
-    self.hash_function_name = hash_function_name
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-    
-def LoginFromString(xml_string):
-    return atom.CreateClassFromXMLString(Login, xml_string)
-    
-
-class Quota(atom.AtomBase):
-  """The Google Apps Quota element"""
-  
-  _tag = 'quota'
-  _namespace = APPS_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _attributes['limit'] = 'limit'
-
-  def __init__(self, limit=None, extension_elements=None,
-               extension_attributes=None, text=None):
-    self.limit = limit
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-    
-def QuotaFromString(xml_string):
-    return atom.CreateClassFromXMLString(Quota, xml_string)
-
-    
-class Name(atom.AtomBase):
-  """The Google Apps Name element"""
-
-  _tag = 'name'
-  _namespace = APPS_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()  
-  _attributes['familyName'] = 'family_name'
-  _attributes['givenName'] = 'given_name'
-  
-  def __init__(self, family_name=None, given_name=None,
-               extension_elements=None, extension_attributes=None, text=None):
-    self.family_name = family_name
-    self.given_name = given_name
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def NameFromString(xml_string):
-    return atom.CreateClassFromXMLString(Name, xml_string)
-
-
-class Nickname(atom.AtomBase):
-  """The Google Apps Nickname element"""
-  
-  _tag = 'nickname'
-  _namespace = APPS_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy() 
-  _attributes['name'] = 'name'
-
-  def __init__(self, name=None,
-               extension_elements=None, extension_attributes=None, text=None):
-    self.name = name
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def NicknameFromString(xml_string):
-    return atom.CreateClassFromXMLString(Nickname, xml_string)
-  
-
-class NicknameEntry(gdata.GDataEntry):
-  """A Google Apps flavor of an Atom Entry for Nickname"""
-  
-  _tag = 'entry'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataEntry._children.copy()
-  _attributes = gdata.GDataEntry._attributes.copy()
-  _children['{%s}login' % APPS_NAMESPACE] = ('login', Login)
-  _children['{%s}nickname' % APPS_NAMESPACE] = ('nickname', Nickname)
-
-  def __init__(self, author=None, category=None, content=None,
-               atom_id=None, link=None, published=None, 
-               title=None, updated=None,
-               login=None, nickname=None,
-               extended_property=None, 
-               extension_elements=None, extension_attributes=None, text=None):
-
-    gdata.GDataEntry.__init__(self, author=author, category=category, 
-                              content=content,
-                              atom_id=atom_id, link=link, published=published,
-                              title=title, updated=updated)
-    self.login = login
-    self.nickname = nickname
-    self.extended_property = extended_property or []
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def NicknameEntryFromString(xml_string):
-  return atom.CreateClassFromXMLString(NicknameEntry, xml_string)
-
-
-class NicknameFeed(gdata.GDataFeed, gdata.LinkFinder):
-  """A Google Apps Nickname feed flavor of an Atom Feed"""
-  
-  _tag = 'feed'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataFeed._children.copy()
-  _attributes = gdata.GDataFeed._attributes.copy()
-  _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [NicknameEntry])
-
-  def __init__(self, author=None, category=None, contributor=None,
-               generator=None, icon=None, atom_id=None, link=None, logo=None, 
-               rights=None, subtitle=None, title=None, updated=None,
-               entry=None, total_results=None, start_index=None,
-               items_per_page=None, extension_elements=None,
-               extension_attributes=None, text=None):
-    gdata.GDataFeed.__init__(self, author=author, category=category,
-                             contributor=contributor, generator=generator,
-                             icon=icon,  atom_id=atom_id, link=link,
-                             logo=logo, rights=rights, subtitle=subtitle,
-                             title=title, updated=updated, entry=entry,
-                             total_results=total_results,
-                             start_index=start_index,
-                             items_per_page=items_per_page,
-                             extension_elements=extension_elements,
-                             extension_attributes=extension_attributes,
-                             text=text)
-
-
-def NicknameFeedFromString(xml_string):
-  return atom.CreateClassFromXMLString(NicknameFeed, xml_string)
-
-
-class UserEntry(gdata.GDataEntry):
-  """A Google Apps flavor of an Atom Entry"""
-  
-  _tag = 'entry'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataEntry._children.copy()
-  _attributes = gdata.GDataEntry._attributes.copy()
-  _children['{%s}login' % APPS_NAMESPACE] = ('login', Login)
-  _children['{%s}name' % APPS_NAMESPACE] = ('name', Name)
-  _children['{%s}quota' % APPS_NAMESPACE] = ('quota', Quota)
-  # This child may already be defined in GDataEntry, confirm before removing.
-  _children['{%s}feedLink' % gdata.GDATA_NAMESPACE] = ('feed_link', 
-                                                       [gdata.FeedLink])
-  _children['{%s}who' % gdata.GDATA_NAMESPACE] = ('who', Who)
-
-  def __init__(self, author=None, category=None, content=None,
-               atom_id=None, link=None, published=None, 
-               title=None, updated=None,
-               login=None, name=None, quota=None, who=None, feed_link=None,
-               extended_property=None, 
-               extension_elements=None, extension_attributes=None, text=None):
-
-    gdata.GDataEntry.__init__(self, author=author, category=category, 
-                              content=content,
-                              atom_id=atom_id, link=link, published=published,
-                              title=title, updated=updated)
-    self.login = login
-    self.name = name
-    self.quota = quota
-    self.who = who
-    self.feed_link = feed_link or []
-    self.extended_property = extended_property or []
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-    
-
-def UserEntryFromString(xml_string):
-  return atom.CreateClassFromXMLString(UserEntry, xml_string)
-
-  
-class UserFeed(gdata.GDataFeed, gdata.LinkFinder):
-  """A Google Apps User feed flavor of an Atom Feed"""
-  
-  _tag = 'feed'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataFeed._children.copy()
-  _attributes = gdata.GDataFeed._attributes.copy()
-  _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [UserEntry])
-
-  def __init__(self, author=None, category=None, contributor=None,
-               generator=None, icon=None, atom_id=None, link=None, logo=None, 
-               rights=None, subtitle=None, title=None, updated=None,
-               entry=None, total_results=None, start_index=None,
-               items_per_page=None, extension_elements=None,
-               extension_attributes=None, text=None):
-    gdata.GDataFeed.__init__(self, author=author, category=category,
-                             contributor=contributor, generator=generator,
-                             icon=icon,  atom_id=atom_id, link=link,
-                             logo=logo, rights=rights, subtitle=subtitle,
-                             title=title, updated=updated, entry=entry,
-                             total_results=total_results,
-                             start_index=start_index,
-                             items_per_page=items_per_page,
-                             extension_elements=extension_elements,
-                             extension_attributes=extension_attributes,
-                             text=text)
-
-
-def UserFeedFromString(xml_string):
-  return atom.CreateClassFromXMLString(UserFeed, xml_string)
-
-
-class EmailListEntry(gdata.GDataEntry):
-  """A Google Apps EmailList flavor of an Atom Entry"""
-  
-  _tag = 'entry'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataEntry._children.copy()
-  _attributes = gdata.GDataEntry._attributes.copy()
-  _children['{%s}emailList' % APPS_NAMESPACE] = ('email_list', EmailList)
-  # Might be able to remove this _children entry.
-  _children['{%s}feedLink' % gdata.GDATA_NAMESPACE] = ('feed_link', 
-                                                       [gdata.FeedLink])
-
-  def __init__(self, author=None, category=None, content=None,
-               atom_id=None, link=None, published=None, 
-               title=None, updated=None,
-               email_list=None, feed_link=None,
-               extended_property=None, 
-               extension_elements=None, extension_attributes=None, text=None):
-
-    gdata.GDataEntry.__init__(self, author=author, category=category, 
-                              content=content,
-                              atom_id=atom_id, link=link, published=published,
-                              title=title, updated=updated)
-    self.email_list = email_list
-    self.feed_link = feed_link or []
-    self.extended_property = extended_property or []
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def EmailListEntryFromString(xml_string):
-  return atom.CreateClassFromXMLString(EmailListEntry, xml_string)
-  
-
-class EmailListFeed(gdata.GDataFeed, gdata.LinkFinder):
-  """A Google Apps EmailList feed flavor of an Atom Feed"""
-  
-  _tag = 'feed'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataFeed._children.copy()
-  _attributes = gdata.GDataFeed._attributes.copy()
-  _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [EmailListEntry])
-
-  def __init__(self, author=None, category=None, contributor=None,
-               generator=None, icon=None, atom_id=None, link=None, logo=None, 
-               rights=None, subtitle=None, title=None, updated=None,
-               entry=None, total_results=None, start_index=None,
-               items_per_page=None, extension_elements=None,
-               extension_attributes=None, text=None):
-    gdata.GDataFeed.__init__(self, author=author, category=category,
-                             contributor=contributor, generator=generator,
-                             icon=icon,  atom_id=atom_id, link=link,
-                             logo=logo, rights=rights, subtitle=subtitle,
-                             title=title, updated=updated, entry=entry,
-                             total_results=total_results,
-                             start_index=start_index,
-                             items_per_page=items_per_page,
-                             extension_elements=extension_elements,
-                             extension_attributes=extension_attributes,
-                             text=text)
-                             
-
-def EmailListFeedFromString(xml_string):
-  return atom.CreateClassFromXMLString(EmailListFeed, xml_string)
-
-
-class EmailListRecipientEntry(gdata.GDataEntry):
-  """A Google Apps EmailListRecipient flavor of an Atom Entry"""
-  
-  _tag = 'entry'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataEntry._children.copy()
-  _attributes = gdata.GDataEntry._attributes.copy()
-  _children['{%s}who' % gdata.GDATA_NAMESPACE] = ('who', Who)
-
-  def __init__(self, author=None, category=None, content=None,
-               atom_id=None, link=None, published=None, 
-               title=None, updated=None,
-               who=None,
-               extended_property=None, 
-               extension_elements=None, extension_attributes=None, text=None):
-
-    gdata.GDataEntry.__init__(self, author=author, category=category, 
-                              content=content,
-                              atom_id=atom_id, link=link, published=published,
-                              title=title, updated=updated)
-    self.who = who
-    self.extended_property = extended_property or []
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def EmailListRecipientEntryFromString(xml_string):
-  return atom.CreateClassFromXMLString(EmailListRecipientEntry, xml_string)
-
-
-class EmailListRecipientFeed(gdata.GDataFeed, gdata.LinkFinder):
-  """A Google Apps EmailListRecipient feed flavor of an Atom Feed"""
-  
-  _tag = 'feed'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataFeed._children.copy()
-  _attributes = gdata.GDataFeed._attributes.copy()
-  _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', 
-                                                  [EmailListRecipientEntry])
-
-  def __init__(self, author=None, category=None, contributor=None,
-               generator=None, icon=None, atom_id=None, link=None, logo=None, 
-               rights=None, subtitle=None, title=None, updated=None,
-               entry=None, total_results=None, start_index=None,
-               items_per_page=None, extension_elements=None,
-               extension_attributes=None, text=None):
-    gdata.GDataFeed.__init__(self, author=author, category=category,
-                             contributor=contributor, generator=generator,
-                             icon=icon,  atom_id=atom_id, link=link,
-                             logo=logo, rights=rights, subtitle=subtitle,
-                             title=title, updated=updated, entry=entry,
-                             total_results=total_results,
-                             start_index=start_index,
-                             items_per_page=items_per_page,
-                             extension_elements=extension_elements,
-                             extension_attributes=extension_attributes,
-                             text=text)
-
-
-def EmailListRecipientFeedFromString(xml_string):
-  return atom.CreateClassFromXMLString(EmailListRecipientFeed, xml_string)
-
-
-class Property(atom.AtomBase):
-  """The Google Apps Property element"""
-
-  _tag = 'property'
-  _namespace = APPS_NAMESPACE
-  _children = atom.AtomBase._children.copy()
-  _attributes = atom.AtomBase._attributes.copy()
-  _attributes['name'] = 'name'
-  _attributes['value'] = 'value'
-
-  def __init__(self, name=None, value=None, extension_elements=None,
-               extension_attributes=None, text=None):
-    self.name = name
-    self.value = value
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def PropertyFromString(xml_string):
-  return atom.CreateClassFromXMLString(Property, xml_string)
-
-
-class PropertyEntry(gdata.GDataEntry):
-  """A Google Apps Property flavor of an Atom Entry"""
-
-  _tag = 'entry'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataEntry._children.copy()
-  _attributes = gdata.GDataEntry._attributes.copy()
-  _children['{%s}property' % APPS_NAMESPACE] = ('property', [Property])
-
-  def __init__(self, author=None, category=None, content=None,
-               atom_id=None, link=None, published=None,
-               title=None, updated=None,
-               property=None,
-               extended_property=None,
-               extension_elements=None, extension_attributes=None, text=None):
-
-    gdata.GDataEntry.__init__(self, author=author, category=category,
-                              content=content,
-                              atom_id=atom_id, link=link, published=published,
-                              title=title, updated=updated)
-    self.property = property
-    self.extended_property = extended_property or []
-    self.text = text
-    self.extension_elements = extension_elements or []
-    self.extension_attributes = extension_attributes or {}
-
-
-def PropertyEntryFromString(xml_string):
-  return atom.CreateClassFromXMLString(PropertyEntry, xml_string)
-
-class PropertyFeed(gdata.GDataFeed, gdata.LinkFinder):
-  """A Google Apps Property feed flavor of an Atom Feed"""
-  
-  _tag = 'feed'
-  _namespace = atom.ATOM_NAMESPACE
-  _children = gdata.GDataFeed._children.copy()
-  _attributes = gdata.GDataFeed._attributes.copy()
-  _children['{%s}entry' % atom.ATOM_NAMESPACE] = ('entry', [PropertyEntry])
-
-  def __init__(self, author=None, category=None, contributor=None,
-               generator=None, icon=None, atom_id=None, link=None, logo=None, 
-               rights=None, subtitle=None, title=None, updated=None,
-               entry=None, total_results=None, start_index=None,
-               items_per_page=None, extension_elements=None,
-               extension_attributes=None, text=None):
-    gdata.GDataFeed.__init__(self, author=author, category=category,
-                             contributor=contributor, generator=generator,
-                             icon=icon,  atom_id=atom_id, link=link,
-                             logo=logo, rights=rights, subtitle=subtitle,
-                             title=title, updated=updated, entry=entry,
-                             total_results=total_results,
-                             start_index=start_index,
-                             items_per_page=items_per_page,
-                             extension_elements=extension_elements,
-                             extension_attributes=extension_attributes,
-                             text=text)
-
-def PropertyFeedFromString(xml_string):
-  return atom.CreateClassFromXMLString(PropertyFeed, xml_string)

gdata/apps/adminsettings/__init__.py

@@ -1,16 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-

gdata/apps/adminsettings/service.py

@@ -1,474 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Allow Google Apps domain administrators to set domain admin settings.
-
-  AdminSettingsService: Set admin settings."""
-
-__author__ = 'jlee@pbu.edu'
-
-
-import gdata.apps
-import gdata.apps.service
-import gdata.service
-
-
-API_VER='2.0'
-
-class AdminSettingsService(gdata.apps.service.PropertyService):
-  """Client for the Google Apps Admin Settings service."""
-
-  def _serviceUrl(self, setting_id, domain=None):
-    if domain is None:
-      domain = self.domain
-    return '/a/feeds/domain/%s/%s/%s' % (API_VER, domain, setting_id)
-
-  def genericGet(self, location):
-    """Generic HTTP Get Wrapper
-
-    Args:
-      location: relative uri to Get
-
-    Returns:
-      A dict containing the result of the get operation."""
-
-    uri = self._serviceUrl(location)
-    try:
-      return self._GetProperties(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def GetDefaultLanguage(self):
-    """Gets Domain Default Language
-
-    Args:
-      None
-
-    Returns:
-      Default Language as a string.  All possible values are listed at:
-        http://code.google.com/apis/apps/email_settings/developers_guide_protocol.html#GA_email_language_tags"""
-
-    result = self.genericGet('general/defaultLanguage')
-    return result['defaultLanguage']
-
-  def UpdateDefaultLanguage(self, defaultLanguage):
-    """Updates Domain Default Language
-
-    Args:
-      defaultLanguage: Domain Language to set
-        possible values are at:
-        http://code.google.com/apis/apps/email_settings/developers_guide_protocol.html#GA_email_language_tags
-
-    Returns:
-      A dict containing the result of the put operation"""
-
-    uri = self._serviceUrl('general/defaultLanguage')
-    properties = {'defaultLanguage': defaultLanguage}
-    return self._PutProperties(uri, properties)
-    
-  def GetOrganizationName(self):
-    """Gets Domain Default Language
-
-    Args:
-      None
-
-    Returns:
-      Organization Name as a string."""
-
-    result = self.genericGet('general/organizationName')
-    return result['organizationName']
-
-
-  def UpdateOrganizationName(self, organizationName):
-    """Updates Organization Name
-
-    Args:
-      organizationName: Name of organization
-
-    Returns:
-      A dict containing the result of the put operation"""
-
-    uri = self._serviceUrl('general/organizationName')
-    properties = {'organizationName': organizationName}
-    return self._PutProperties(uri, properties)
-
-  def GetMaximumNumberOfUsers(self):
-    """Gets Maximum Number of Users Allowed
-
-    Args:
-      None
-
-    Returns: An integer, the maximum number of users"""
-
-    result = self.genericGet('general/maximumNumberOfUsers')
-    return int(result['maximumNumberOfUsers'])
-
-  def GetCurrentNumberOfUsers(self):
-    """Gets Current Number of Users
-
-    Args:
-      None
-
-    Returns: An integer, the current number of users"""
-
-    result = self.genericGet('general/currentNumberOfUsers')
-    return int(result['currentNumberOfUsers'])
-
-  def IsDomainVerified(self):
-    """Is the domain verified
-
-    Args:
-      None
-
-    Returns: Boolean, is domain verified"""
-
-    result = self.genericGet('accountInformation/isVerified')
-    if result['isVerified'] == 'true':
-      return True
-    else:
-      return False
-
-  def GetSupportPIN(self):
-    """Gets Support PIN
-
-    Args:
-      None
-
-    Returns: A string, the Support PIN"""
-
-    result = self.genericGet('accountInformation/supportPIN')
-    return result['supportPIN']
-
-  def GetEdition(self):
-    """Gets Google Apps Domain Edition
-
-    Args:
-      None
-
-    Returns: A string, the domain's edition (premier, education, partner)"""
-
-    result = self.genericGet('accountInformation/edition')
-    return result['edition']
-
-  def GetCustomerPIN(self):
-    """Gets Customer PIN
-
-    Args:
-      None
-
-    Returns: A string, the customer PIN"""
-
-    result = self.genericGet('accountInformation/customerPIN')
-    return result['customerPIN']
-
-  def GetCreationTime(self):
-    """Gets Domain Creation Time
-
-    Args:
-      None
-
-    Returns: A string, the domain's creation time"""
-
-    result = self.genericGet('accountInformation/creationTime')
-    return result['creationTime']
-
-  def GetCountryCode(self):
-    """Gets Domain Country Code
-
-    Args:
-      None
-
-    Returns: A string, the domain's country code. Possible values at:
-      http://www.iso.org/iso/country_codes/iso_3166_code_lists/english_country_names_and_code_elements.htm"""
-
-    result = self.genericGet('accountInformation/countryCode')
-    return result['countryCode']
-
-  def GetAdminSecondaryEmail(self):
-    """Gets Domain Admin Secondary Email Address
-
-    Args:
-      None
-
-    Returns: A string, the secondary email address for domain admin"""
-
-    result = self.genericGet('accountInformation/adminSecondaryEmail')
-    return result['adminSecondaryEmail']
-
-  def UpdateAdminSecondaryEmail(self, adminSecondaryEmail):
-    """Gets Domain Creation Time
-
-    Args:
-      adminSecondaryEmail: string, secondary email address of admin
-
-    Returns: A dict containing the result of the put operation"""
-
-    uri = self._serviceUrl('accountInformation/adminSecondaryEmail')
-    properties = {'adminSecondaryEmail': adminSecondaryEmail}
-    return self._PutProperties(uri, properties)
-
-  def GetDomainLogo(self):
-    """Gets Domain Logo
-
-    This function does not make use of the Google Apps Admin Settings API,
-    it does an HTTP Get of a url specific to the Google Apps domain. It is
-    included for completeness sake.
-
-    Args:
-      None
-
-    Returns: binary image file"""
- 
-    import urllib
-    url = 'http://www.google.com/a/cpanel/'+self.domain+'/images/logo.gif'
-    response = urllib.urlopen(url)
-    return response.read()
-
-  def UpdateDomainLogo(self, logoImage):
-    """Update Domain's Custom Logo
-
-    Args:
-      logoImage: binary image data
-
-    Returns: A dict containing the result of the put operation"""
-
-    from base64 import b64encode
-    uri = self._serviceUrl('appearance/customLogo')
-    properties = {'logoImage': b64encode(logoImage)}
-    return self._PutProperties(uri, properties)
-
-  def GetCNAMEVerificationStatus(self):
-    """Gets Domain CNAME Verification Status
-
-    Args:
-      None
-
-    Returns: A dict {recordName, verified, verifiedMethod}"""
-
-    return self.genericGet('verification/cname')
-
-  def UpdateCNAMEVerificationStatus(self, verified='true'):
-    """Updates CNAME Verification Status
-
-    Args:
-      verified: boolean, True will retry verification process
-
-    Returns: A dict containing the result of the put operation"""
-
-    uri = self._serviceUrl('verification/cname')
-    properties = self.GetCNAMEVerificationStatus()
-    properties['verified'] = verified
-    return self._PutProperties(uri, properties)
-
-  def GetMXVerificationStatus(self):
-    """Gets Domain MX Verification Status
-
-    Args:
-      None
-
-    Returns: A dict {verified, verifiedMethod}"""
-
-    return self.genericGet('verification/mx')
-
-  def UpdateMXVerificationStatus(self, verified='true'):
-    """Updates MX Verification Status
-
-    Args:
-      verified: boolean, True will retry verification process
-
-    Returns: A dict containing the result of the put operation"""
-
-    uri = self._serviceUrl('verification/mx')
-    properties = self.GetMXVerificationStatus()
-    properties['verified'] = verified
-    return self._PutProperties(uri, properties)
-
-  def GetSSOSettings(self):
-    """Gets Domain Single Sign-On Settings
-
-    Args:
-      None
-
-    Returns: A dict {samlSignonUri, samlLogoutUri, changePasswordUri, enableSSO, ssoWhitelist, useDomainSpecificIssuer}"""
-
-    return self.genericGet('sso/general')
-
-  def UpdateSSOSettings(self, enableSSO=None, samlSignonUri=None,
-                        samlLogoutUri=None, changePasswordUri=None,
-                        ssoWhitelist=None, useDomainSpecificIssuer=None):
-    """Update SSO Settings.
-
-    Args:
-      enableSSO: boolean, SSO Master on/off switch
-      samlSignonUri: string, SSO Login Page
-      samlLogoutUri: string, SSO Logout Page
-      samlPasswordUri: string, SSO Password Change Page
-      ssoWhitelist: string, Range of IP Addresses which will see SSO
-      useDomainSpecificIssuer: boolean, Include Google Apps Domain in Issuer
-
-    Returns:
-      A dict containing the result of the update operation.
-    """
-    uri = self._serviceUrl('sso/general')
-
-    #Get current settings, replace Nones with ''
-    properties = self.GetSSOSettings()
-    if properties['samlSignonUri'] == None:
-      properties['samlSignonUri'] = ''
-    if properties['samlLogoutUri'] == None:
-      properties['samlLogoutUri'] = ''
-    if properties['changePasswordUri'] == None:
-      properties['changePasswordUri'] = ''
-    if properties['ssoWhitelist'] == None:
-      properties['ssoWhitelist'] = ''
-
-    #update only the values we were passed
-    if enableSSO != None:
-      properties['enableSSO'] = gdata.apps.service._bool2str(enableSSO)
-    if samlSignonUri != None:
-      properties['samlSignonUri'] = samlSignonUri
-    if samlLogoutUri != None:
-      properties['samlLogoutUri'] = samlLogoutUri
-    if changePasswordUri != None:
-      properties['changePasswordUri'] = changePasswordUri
-    if ssoWhitelist != None:
-      properties['ssoWhitelist'] = ssoWhitelist
-    if useDomainSpecificIssuer != None:
-      properties['useDomainSpecificIssuer'] = gdata.apps.service._bool2str(useDomainSpecificIssuer)
-
-    return self._PutProperties(uri, properties)
-
-  def GetSSOKey(self):
-    """Gets Domain Single Sign-On Signing Key
-
-    Args:
-      None
-
-    Returns: A dict {modulus, exponent, algorithm, format}"""
-
-    return self.genericGet('sso/signingkey')
-
-  def UpdateSSOKey(self, signingKey):
-    """Update SSO Settings.
-
-    Args:
-      signingKey: binary, public key to be uploaded
-
-    Returns:
-      A dict containing the result of the update operation."""
-
-    from base64 import b64encode
-    uri = self._serviceUrl('sso/signingkey')
-    properties = {'signingKey': b64encode(signingKey)}
-    return self._PutProperties(uri, properties)
-
-  def IsUserMigrationEnabled(self):
-    """Is User Migration Enabled
-
-    Args:
-      None
-
-    Returns:
-      boolean, is user migration enabled"""
-
-    result = self.genericGet('email/migration')
-    if result['enableUserMigration'] == 'true':
-      return True
-    else:
-      return False
-
-  def UpdateUserMigrationStatus(self, enableUserMigration):
-    """Update User Migration Status
-
-    Args:
-      enableUserMigration: boolean, user migration enable/disable
-
-    Returns:
-      A dict containing the result of the update operation."""
-
-    uri = self._serviceUrl('email/migration')
-    properties = {'enableUserMigration': enableUserMigration}
-    return self._PutProperties(uri, properties)
-
-  def GetOutboundGatewaySettings(self):
-    """Get Outbound Gateway Settings
-
-    Args:
-      None
-
-    Returns:
-      A dict {smartHost, smtpMode}"""
-
-    uri = self._serviceUrl('email/gateway')
-    try:
-      return self._GetProperties(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-    except TypeError:
-      #if no outbound gateway is set, we get a TypeError,
-      #catch it and return nothing...
-      return {'smartHost': None, 'smtpMode': None}
-
-  def UpdateOutboundGatewaySettings(self, smartHost=None, smtpMode=None):
-    """Update Outbound Gateway Settings
-
-    Args:
-      smartHost: string, ip address or hostname of outbound gateway
-      smtpMode: string, SMTP or SMTP_TLS
-
-    Returns:
-      A dict containing the result of the update operation."""
-
-    uri = self._serviceUrl('email/gateway')
-
-    #Get current settings, replace Nones with ''
-    properties = self.GetOutboundGatewaySettings()
-    if properties['smartHost'] == None:
-      properties['smartHost'] = ''
-    try:
-      if properties['smtpMode'] == None:
-        properties['smtpMode'] = ''
-    except KeyError:
-      properties['smtpMode'] = ''
-
-    #If we were passed new values for smartHost or smtpMode, update them
-    if smartHost != None:
-      properties['smartHost'] = smartHost
-    if smtpMode != None:
-      properties['smtpMode'] = smtpMode
-    return self._PutProperties(uri, properties)
-
-  def AddEmailRoute(self, routeDestination, routeRewriteTo, routeEnabled, bounceNotifications, accountHandling):
-    """Adds Domain Email Route
-
-    Args:
-      routeDestination: string, destination ip address or hostname
-      routeRewriteTo: boolean, rewrite smtp envelop To:
-      routeEnabled: boolean, enable disable email routing
-      bounceNotifications: boolean, send bound notificiations to sender
-      accountHandling: string, which to route, "allAccounts", "provisionedAccounts", "unknownAccounts"
-
-    Returns:
-      A dict containing the result of the update operation."""
-
-    uri = self._serviceUrl('emailrouting')
-    properties = {}
-    properties['routeDestination'] = routeDestination
-    properties['routeRewriteTo'] = gdata.apps.service._bool2str(routeRewriteTo)
-    properties['routeEnabled'] = gdata.apps.service._bool2str(routeEnabled)
-    properties['bounceNotifications'] = gdata.apps.service._bool2str(bounceNotifications)
-    properties['accountHandling'] = accountHandling
-    return self._PostProperties(uri, properties)

gdata/apps/audit/__init__.py

@@ -1 +0,0 @@
-

gdata/apps/audit/service.py

@@ -1,277 +0,0 @@
-# Copyright (C) 2008 Google, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Allow Google Apps domain administrators to audit user data.
-
-  AuditService: Set auditing."""
-
-__author__ = 'jlee@pbu.edu'
-
-from base64 import b64encode
-
-import gdata.apps
-import gdata.apps.service
-import gdata.service
-
-class AuditService(gdata.apps.service.PropertyService):
-  """Client for the Google Apps Audit service."""
-
-  def _serviceUrl(self, setting_id, domain=None, user=None):
-    if domain is None:
-      domain = self.domain
-    if user is None:
-      return '/a/feeds/compliance/audit/%s/%s' % (setting_id, domain)
-    else:
-      return '/a/feeds/compliance/audit/%s/%s/%s' % (setting_id, domain, user)
-
-  def updatePGPKey(self, pgpkey):
-    """Updates Public PGP Key Google uses to encrypt audit data
-
-    Args:
-      pgpkey: string, ASCII text of PGP Public Key to be used
-
-    Returns:
-      A dict containing the result of the POST operation."""
-
-    uri = self._serviceUrl('publickey')
-    b64pgpkey = b64encode(pgpkey)
-    properties = {}
-    properties['publicKey'] = b64pgpkey
-    return self._PostProperties(uri, properties)
-
-  def createEmailMonitor(self, source_user, destination_user, end_date, 
-                         begin_date=None, incoming_headers_only=False, 
-                         outgoing_headers_only=False, drafts=False, 
-                         drafts_headers_only=False, chats=False, 
-                         chats_headers_only=False):
-    """Creates a email monitor, forwarding the source_users emails/chats
-
-    Args:
-      source_user: string, the user whose email will be audited
-      destination_user: string, the user to receive the audited email
-      end_date: string, the date the audit will end in
-                "yyyy-MM-dd HH:mm" format, required
-      begin_date: string, the date the audit will start in 
-                  "yyyy-MM-dd HH:mm" format, leave blank to use current time
-      incoming_headers_only: boolean, whether to audit only the headers of
-                             mail delivered to source user
-      outgoing_headers_only: boolean, whether to audit only the headers of
-                             mail sent from the source user
-      drafts: boolean, whether to audit draft messages of the source user
-      drafts_headers_only: boolean, whether to audit only the headers of
-                           mail drafts saved by the user
-      chats: boolean, whether to audit archived chats of the source user
-      chats_headers_only: boolean, whether to audit only the headers of
-                          archived chats of the source user
-
-    Returns:
-      A dict containing the result of the POST operation."""
-
-    uri = self._serviceUrl('mail/monitor', user=source_user)
-    properties = {}
-    properties['destUserName'] = destination_user
-    if begin_date is not None:
-      properties['beginDate'] = begin_date
-    properties['endDate'] = end_date
-    if incoming_headers_only:
-      properties['incomingEmailMonitorLevel'] = 'HEADER_ONLY'
-    else:
-      properties['incomingEmailMonitorLevel'] = 'FULL_MESSAGE'
-    if outgoing_headers_only:
-      properties['outgoingEmailMonitorLevel'] = 'HEADER_ONLY'
-    else:
-      properties['outgoingEmailMonitorLevel'] = 'FULL_MESSAGE'
-    if drafts:
-      if drafts_headers_only:
-        properties['draftMonitorLevel'] = 'HEADER_ONLY'
-      else:
-        properties['draftMonitorLevel'] = 'FULL_MESSAGE'
-    if chats:
-      if chats_headers_only:
-        properties['chatMonitorLevel'] = 'HEADER_ONLY'
-      else:
-        properties['chatMonitorLevel'] = 'FULL_MESSAGE'
-    return self._PostProperties(uri, properties)
-
-  def getEmailMonitors(self, user):
-    """"Gets the email monitors for the given user
-
-    Args:
-      user: string, the user to retrieve email monitors for
-
-    Returns:
-      list results of the POST operation
-
-    """
-    uri = self._serviceUrl('mail/monitor', user=user)
-    return self._GetPropertiesList(uri)
-
-  def deleteEmailMonitor(self, source_user, destination_user):
-    """Deletes the email monitor for the given user
-
-    Args:
-      source_user: string, the user who is being monitored
-      destination_user: string, theuser who recieves the monitored emails
-
-    Returns:
-      Nothing
-    """
-
-    uri = self._serviceUrl('mail/monitor', user=source_user+'/'+destination_user)
-    try:
-      return self._DeleteProperties(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def createAccountInformationRequest(self, user):
-    """Creates a request for account auditing details
-
-    Args:
-      user: string, the user to request account information for
-
-    Returns:
-      A dict containing the result of the post operation."""
-
-    uri = self._serviceUrl('account', user=user)
-    properties = {}
-    #XML Body is left empty
-    try:
-      return self._PostProperties(uri, properties)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def getAccountInformationRequestStatus(self, user, request_id):
-    """Gets the status of an account auditing request
-
-    Args:
-      user: string, the user whose account auditing details were requested
-      request_id: string, the request_id
-
-    Returns:
-      A dict containing the result of the get operation."""
-
-    uri = self._serviceUrl('account', user=user+'/'+request_id)
-    try:
-      return self._GetProperties(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def getAllAccountInformationRequestsStatus(self):
-    """Gets the status of all account auditing requests for the domain
-
-    Args:
-      None
-
-    Returns:
-      list results of the POST operation
-    """
-
-    uri = self._serviceUrl('account')
-    return self._GetPropertiesList(uri)
-
-
-  def deleteAccountInformationRequest(self, user, request_id):
-    """Deletes the request for account auditing information
-
-   Args:
-     user: string, the user whose account auditing details were requested
-     request_id: string, the request_id
-
-   Returns:
-     Nothing
-   """
-
-    uri = self._serviceUrl('account', user=user+'/'+request_id)
-    try:
-      return self._DeleteProperties(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def createMailboxExportRequest(self, user, begin_date=None, end_date=None, include_deleted=False, search_query=None, headers_only=False):
-    """Creates a mailbox export request
-
-    Args:
-      user: string, the user whose mailbox export is being requested
-      begin_date: string, date of earliest emails to export, optional, defaults to date of account creation
-                  format is 'yyyy-MM-dd HH:mm'
-      end_date: string, date of latest emails to export, optional, defaults to current date
-                format is 'yyyy-MM-dd HH:mm'
-      include_deleted: boolean, whether to include deleted emails in export, mutually exclusive with search_query
-      search_query: string, gmail style search query, matched emails will be exported, mutually exclusive with include_deleted
-
-    Returns:
-      A dict containing the result of the post operation."""
-
-    uri = self._serviceUrl('mail/export', user=user)
-    properties = {}
-    if begin_date is not None:
-      properties['beginDate'] = begin_date
-    if end_date is not None:
-      properties['endDate'] = end_date
-    if include_deleted is not None:
-      properties['includeDeleted'] = gdata.apps.service._bool2str(include_deleted)
-    if search_query is not None:
-      properties['searchQuery'] = search_query
-    if headers_only is True:
-      properties['packageContent'] = 'HEADER_ONLY'
-    else:
-      properties['packageContent'] = 'FULL_MESSAGE'
-    return self._PostProperties(uri, properties)
-
-  def getMailboxExportRequestStatus(self, user, request_id):
-    """Gets the status of an mailbox export request
-
-    Args:
-      user: string, the user whose mailbox were requested
-      request_id: string, the request_id
-
-    Returns:
-      A dict containing the result of the get operation."""
-
-    uri = self._serviceUrl('mail/export', user=user+'/'+request_id)
-    try:
-      return self._GetProperties(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def getAllMailboxExportRequestsStatus(self):
-    """Gets the status of all mailbox export requests for the domain
-
-    Args:
-      None
-
-    Returns:
-      list results of the POST operation
-    """
-
-    uri = self._serviceUrl('mail/export')
-    return self._GetPropertiesList(uri)
-
-
-  def deleteMailboxExportRequest(self, user, request_id):
-    """Deletes the request for mailbox export
-
-   Args:
-     user: string, the user whose mailbox were requested
-     request_id: string, the request_id
-
-   Returns:
-     Nothing
-   """
-
-    uri = self._serviceUrl('mail/export', user=user+'/'+request_id)
-    try:
-      return self._DeleteProperties(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])

gdata/apps/emailsettings/__init__.py

@@ -1,15 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.

gdata/apps/emailsettings/service.py

@@ -1,394 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2008 Google, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Allow Google Apps domain administrators to set users' email settings.
-
-  EmailSettingsService: Set various email settings.
-"""
-
-__author__ = 'google-apps-apis@googlegroups.com'
-
-
-import gdata.apps
-import gdata.apps.service
-import gdata.service
-
-import urllib
-
-API_VER='2.0'
-# Forwarding and POP3 options
-KEEP='KEEP'
-ARCHIVE='ARCHIVE'
-DELETE='DELETE'
-ALL_MAIL='ALL_MAIL'
-MAIL_FROM_NOW_ON='MAIL_FROM_NOW_ON'
-
-
-class EmailSettingsService(gdata.apps.service.PropertyService):
-  """Client for the Google Apps Email Settings service."""
-
-  def _serviceUrl(self, setting_id, username, domain=None):
-    if domain is None:
-      domain = self.domain
-    return '/a/feeds/emailsettings/%s/%s/%s/%s' % (API_VER, domain, username,
-                                                   setting_id)
-
-  def CreateLabel(self, username, label):
-    """Create a label.
-
-    Args:
-      username: User to create label for.
-      label: Label to create.
-
-    Returns:
-      A dict containing the result of the create operation.
-    """
-    uri = self._serviceUrl('label', username)
-    properties = {'label': label}
-    return self._PostProperties(uri, properties)
-
-  def DeleteLabel(self, username, label):
-    """Delete a label.
-
-    Args:
-      username: User to delete label for.
-      label: Label to delete.
-    
-    Returns:
-      Nothing
-    """
-    label = urllib.quote_plus(label, '')
-    uri = self._serviceUrl('label/%s' % label, username)
-    return self._DeleteProperties(uri)
-    
-  def GetLabels(self, username):
-    """Get labels for a user.
-
-    Args:
-      username: User to retrieve labels for.
-
-    Returns:
-      A list of labels
-    """
-    uri = self._serviceUrl('label', username)
-    return self._GetPropertiesList(uri)
-
-  def CreateFilter(self, username, from_=None, to=None, subject=None,
-                   has_the_word=None, does_not_have_the_word=None,
-                   has_attachment=None, label=None, should_mark_as_read=None,
-                   should_archive=None, should_star=None, forward_to=None,
-                   should_trash=None, should_not_spam=None):
-    """Create a filter.
-
-    Args:
-      username: User to create filter for.
-      from_: Filter from string.
-      to: Filter to string.
-      subject: Filter subject.
-      has_the_word: Words to filter in.
-      does_not_have_the_word: Words to filter out.
-      has_attachment:  Boolean for message having attachment.
-      label: Label to apply.
-      should_mark_as_read: Boolean for marking message as read.
-      should_archive: Boolean for archiving message.
-      should_star: Boolean for starring message
-      forward_to: string email address to forward message to
-      should_trash: Boolean for trashing message
-      should_not_spam: Boolean for never sending message to spam
-
-    Returns:
-      A dict containing the result of the create operation.
-    """
-    uri = self._serviceUrl('filter', username)
-    properties = {}
-    if from_ != None:
-      properties['from'] = from_
-    if to != None:
-      properties['to'] = to
-    if subject != None:
-      properties['subject'] = subject
-    if has_the_word != None:
-      properties['hasTheWord'] = has_the_word
-    if does_not_have_the_word != None:
-      properties['doesNotHaveTheWord'] = does_not_have_the_word
-    if has_attachment != None:
-      properties['hasAttachment'] = gdata.apps.service._bool2str(has_attachment)
-    if label != None:
-      properties['label'] = label
-    if should_mark_as_read != None:
-      properties['shouldMarkAsRead'] = gdata.apps.service._bool2str(should_mark_as_read)
-    if should_archive != None:
-      properties['shouldArchive'] = gdata.apps.service._bool2str(should_archive)
-    if should_star != None:
-      properties['shouldStar'] = gdata.apps.service._bool2str(should_star)
-    if forward_to != None:
-      properties['forwardTo'] = forward_to
-    if should_trash != None:
-      properties['shouldTrash'] = gdata.apps.service._bool2str(should_trash)
-    if should_not_spam != None:
-      properties['neverSpam'] = gdata.apps.service._bool2str(should_not_spam)
-    return self._PostProperties(uri, properties)
-
-  def CreateSendAsAlias(self, username, name, address, reply_to=None,
-                        make_default=None):
-    """Create alias to send mail as.
-
-    Args:
-      username: User to create alias for.
-      name: Name of alias.
-      address: Email address to send from.
-      reply_to: Email address to reply to.
-      make_default: Boolean for whether this is the new default sending alias.
-
-    Returns:
-      A dict containing the result of the create operation.
-    """
-    uri = self._serviceUrl('sendas', username)
-    properties = {}
-    properties['name'] = name
-    properties['address'] = address
-    properties['replyTo'] = reply_to
-    properties['makeDefault'] = gdata.apps.service._bool2str(make_default)
-    return self._PostProperties(uri, properties)
-
-  def GetSendAsAlias(self, username):
-    """Retrieve send as aliases for a user.
-
-    Args:
-      username: User to retrieve send as aliases for
-
-    Return:
-      Alist containg the user's send as aliases.
-    """
-    uri = self._serviceUrl('sendas', username)
-    return self._GetPropertiesList(uri)
-
-  def UpdateWebClipSettings(self, username, enable):
-    """Update WebClip Settings
-
-    Args:
-      username: User to update forwarding for.
-      enable: Boolean whether to enable Web Clip.
-    Returns:
-      A dict containing the result of the update operation.
-    """
-    uri = self._serviceUrl('webclip', username)
-    properties = {}
-    properties['enable'] = gdata.apps.service._bool2str(enable)
-    return self._PutProperties(uri, properties)
-
-  def UpdateForwarding(self, username, enable, forward_to=None, action=None):
-    """Update forwarding settings.
-
-    Args:
-      username: User to update forwarding for.
-      enable: Boolean whether to enable this forwarding rule.
-      forward_to: Email address to forward to.
-      action: Action to take after forwarding.
-
-    Returns:
-      A dict containing the result of the update operation.
-    """
-    uri = self._serviceUrl('forwarding', username)
-    properties = {}
-    properties['enable'] = gdata.apps.service._bool2str(enable)
-    if enable is True:
-      properties['forwardTo'] = forward_to
-      properties['action'] = action
-    return self._PutProperties(uri, properties)
-
-  def UpdatePop(self, username, enable, enable_for=None, action=None):
-    """Update POP3 settings.
-
-    Args:
-      username: User to update POP3 settings for.
-      enable: Boolean whether to enable POP3.
-      enable_for: Which messages to make available via POP3.
-      action: Action to take after user retrieves email via POP3.
-
-    Returns:
-      A dict containing the result of the update operation.
-    """
-    uri = self._serviceUrl('pop', username)
-    properties = {}
-    properties['enable'] = gdata.apps.service._bool2str(enable)
-    if enable is True:
-      properties['enableFor'] = enable_for
-      properties['action'] = action
-    return self._PutProperties(uri, properties)
-
-  def GetPop(self, username):
-    uri = self._serviceUrl('pop', username)
-    return self._GetProperties(uri)
-
-  def GetImap(self, username):
-    uri = self._serviceUrl('imap', username)
-    return self._GetProperties(uri)
-
-  def UpdateImap(self, username, enable):
-    """Update IMAP settings.
-
-    Args:
-      username: User to update IMAP settings for.
-      enable: Boolean whether to enable IMAP.
-
-    Returns:
-      A dict containing the result of the update operation.
-    """
-    uri = self._serviceUrl('imap', username)
-    properties = {'enable': gdata.apps.service._bool2str(enable)}
-    return self._PutProperties(uri, properties)
-
-  def GetVacation(self, username):
-    uri = self._serviceUrl('vacation', username)
-    return self._GetProperties(uri)
-
-  def GetForward(self, username):
-    uri = self._serviceUrl('forwarding', username)
-    return self._GetProperties(uri)
-
-  def UpdateVacation(self, username, enable, subject=None, message=None,
-                     contacts_only=None, domain_only=None, start_date=None, end_date=None):
-    """Update vacation settings.
-
-    Args:
-      username: User to update vacation settings for.
-      enable: Boolean whether to enable vacation responses.
-      subject: Vacation message subject.
-      message: Vacation message body.
-      contacts_only: Boolean whether to send message only to contacts.
-	  domain_only: Boolean Whether to only send the autoresponse to users in the same primary domain as the user taking the vacation.
-	  start_date: String "YYYY-MM-DD" The first day when the vacation responder was enabled for the user. In this version of the API, the startDate is in the UTC timezone, not the user's timezone.
-	  end_date: String "YYYY-MM-DD" The last day until which vacation responder is enabled for the user. In this version of the API, the endDate is the UTC timezone, not the user's timezone.
-
-    Returns:
-      A dict containing the result of the update operation.
-    """
-    uri = self._serviceUrl('vacation', username)
-    properties = {}
-    properties['enable'] = gdata.apps.service._bool2str(enable)
-    if enable is True:
-      properties['subject'] = subject
-      properties['message'] = message
-      if contacts_only != None:
-        properties['contactsOnly'] = gdata.apps.service._bool2str(contacts_only)
-      if domain_only != None:
-        properties['domainOnly'] = gdata.apps.service._bool2str(domain_only)
-      if start_date != None:
-        properties['startDate'] = start_date
-      if end_date != None:
-        properties['endDate'] = end_date
-    return self._PutProperties(uri, properties)
-
-  def UpdateSignature(self, username, signature):
-    """Update signature.
-
-    Args:
-      username: User to update signature for.
-      signature: Signature string.
-
-    Returns:
-      A dict containing the result of the update operation.
-    """
-    uri = self._serviceUrl('signature', username)
-    properties = {'signature': signature}
-    return self._PutProperties(uri, properties)
-
-  def GetSignature(self, username):
-    uri = self._serviceUrl('signature', username)
-    return self._GetProperties(uri)
-
-  def CreateDelegate(self, delegate, delegator):
-    """Create delegate
-    
-    Args:
-      delegate: User who will have access to delegator's account
-      delegator: User whose account will be accessible by delegate
-      
-    Returns:
-      A dict containing the result of the operation.
-    """
-    uri = self._serviceUrl('delegation', delegator)
-    properties = {'address': delegate}
-    return self._PostProperties(uri, properties)
-
-  def GetDelegates(self, delegator):
-    """Retrieve delegates
-    
-    Args:
-      delegator: User whose account is accessible by retrieved delegates
-    
-    Returns:
-      A dict contaning the delegates
-    """
-    uri = self._serviceUrl('delegation', delegator)
-    return self._GetPropertiesList(uri)
-
-  def DeleteDelegate(self, delegate, delegator):
-    """Delete delegate
-    
-    Args:
-      delegate: User account who has access to delegator's account
-      delegator: Email address whose account will no longer be accessible by delegate
-      
-    Returns:
-      A dict containing the result of the operation.
-    """
-    uri = self._serviceUrl('delegation', delegator)+"/%s" % delegate
-    return self._DeleteProperties(uri)
-
-  def UpdateLanguage(self, username, language):
-    """Update user interface language.
-
-    Args:
-      username: User to update language for.
-      language: Language code.
-
-    Returns:
-      A dict containing the result of the update operation.
-    """
-    uri = self._serviceUrl('language', username)
-    properties = {'language': language}
-    return self._PutProperties(uri, properties)
-
-  def UpdateGeneral(self, username, page_size=None, shortcuts=None, arrows=None,
-                    snippets=None, unicode=None):
-    """Update general settings.
-
-    Args:
-      username: User to update general settings for.
-      page_size: Number of messages to show.
-      shortcuts: Boolean whether shortcuts are enabled.
-      arrows: Boolean whether arrows are enabled.
-      snippets: Boolean whether snippets are enabled.
-      unicode: Wheter unicode is enabled.
-
-    Returns:
-      A dict containing the result of the update operation.
-    """
-    uri = self._serviceUrl('general', username)
-    properties = {}
-    if page_size != None:
-      properties['pageSize'] = str(page_size)
-    if shortcuts != None:
-      properties['shortcuts'] = gdata.apps.service._bool2str(shortcuts)
-    if arrows != None:
-      properties['arrows'] = gdata.apps.service._bool2str(arrows)
-    if snippets != None:
-      properties['snippets'] = gdata.apps.service._bool2str(snippets)
-    if unicode != None:
-      properties['unicode'] = gdata.apps.service._bool2str(unicode)
-    return self._PutProperties(uri, properties)

gdata/apps/res_cal/__init__.py

@@ -1 +0,0 @@
-

gdata/apps/res_cal/service.py

@@ -1,71 +0,0 @@
-# Copyright (C) 2008 Google, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Allow Google Apps domain administrators to create/modify/delete resource calendars.
-
-  ResCalService: Interact with Resource Calendars."""
-
-__author__ = 'jlee@pbu.edu'
-
-import gdata.apps
-import gdata.apps.service
-import gdata.service
-
-class ResCalService(gdata.apps.service.PropertyService):
-  """Client for the Google Apps Resource Calendar service."""
-
-  def _serviceUrl(self, domain=None):
-    if domain is None:
-      domain = self.domain
-    return '/a/feeds/calendar/resource/2.0/%s' % domain
-
-  def CreateResourceCalendar(self, id, common_name, description=None, type=None):
-  
-    uri = self._serviceUrl()
-    properties = {}
-    properties['resourceId'] = id
-    properties['resourceCommonName'] = common_name
-    if description != None:
-      properties['resourceDescription'] = description
-    if type != None:
-      properties['resourceType'] = type
-    return self._PostProperties(uri, properties)
-
-  def RetrieveResourceCalendar(self, id):
-  
-    uri = self._serviceUrl()+'/'+id
-    return self._GetProperties(uri)
-
-  def RetrieveAllResourceCalendars(self):
-  
-    uri = self._serviceUrl()+'/'
-    return self._GetPropertiesList(uri)
-
-  def UpdateResourceCalendar(self, id, common_name=None, description=None, type=None):
-  
-    uri = self._serviceUrl()+'/'+id
-    properties = {}
-    properties['resourceId'] = id
-    if common_name != None:
-      properties['resourceCommonName'] = common_name
-    if description != None:
-      properties['resourceDescription'] = description
-    if type != None:
-      properties['resourceType'] = type
-    return self._PutProperties(uri, properties)
-
-  def DeleteResourceCalendar(self, id):
-  
-    uri = self._serviceUrl()+'/'+id
-    return self._DeleteProperties(uri)

gdata/apps/service.py

@@ -1,553 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2007 SIOS Technology, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-__author__ = 'tmatsuo@sios.com (Takashi MATSUO)'
-
-try:
-  from xml.etree import cElementTree as ElementTree
-except ImportError:
-  try:
-    import cElementTree as ElementTree
-  except ImportError:
-    try:
-      from xml.etree import ElementTree
-    except ImportError:
-      from elementtree import ElementTree
-import urllib
-import gdata
-import atom.service
-import gdata.service
-import gdata.apps
-import atom
-
-API_VER="2.0"
-HTTP_OK=200
-
-UNKOWN_ERROR=1000
-USER_DELETED_RECENTLY=1100
-USER_SUSPENDED=1101
-DOMAIN_USER_LIMIT_EXCEEDED=1200
-DOMAIN_ALIAS_LIMIT_EXCEEDED=1201
-DOMAIN_SUSPENDED=1202
-DOMAIN_FEATURE_UNAVAILABLE=1203
-ENTITY_EXISTS=1300
-ENTITY_DOES_NOT_EXIST=1301
-ENTITY_NAME_IS_RESERVED=1302
-ENTITY_NAME_NOT_VALID=1303
-INVALID_GIVEN_NAME=1400
-INVALID_FAMILY_NAME=1401
-INVALID_PASSWORD=1402
-INVALID_USERNAME=1403
-INVALID_HASH_FUNCTION_NAME=1404
-INVALID_HASH_DIGGEST_LENGTH=1405
-INVALID_EMAIL_ADDRESS=1406
-INVALID_QUERY_PARAMETER_VALUE=1407
-TOO_MANY_RECIPIENTS_ON_EMAIL_LIST=1500
-
-DEFAULT_QUOTA_LIMIT='2048'
-
-
-class Error(Exception):
-  pass
-
-
-class AppsForYourDomainException(Error):
-
-  def __init__(self, response):
-
-    Error.__init__(self, response)
-    try:
-      self.element_tree = ElementTree.fromstring(response['body'])
-      self.error_code = int(self.element_tree[0].attrib['errorCode'])
-      self.reason = self.element_tree[0].attrib['reason']
-      self.invalidInput = self.element_tree[0].attrib['invalidInput']
-    except:
-      self.error_code = 600
-
-class AppsService(gdata.service.GDataService):
-  """Client for the Google Apps Provisioning service."""
-
-  def __init__(self, email=None, password=None, domain=None, source=None,
-               server='apps-apis.google.com', additional_headers=None,
-               **kwargs):
-    """Creates a client for the Google Apps Provisioning service.
-
-    Args:
-      email: string (optional) The user's email address, used for
-          authentication.
-      password: string (optional) The user's password.
-      domain: string (optional) The Google Apps domain name.
-      source: string (optional) The name of the user's application.
-      server: string (optional) The name of the server to which a connection
-          will be opened. Default value: 'apps-apis.google.com'.
-      **kwargs: The other parameters to pass to gdata.service.GDataService
-          constructor.
-    """
-    gdata.service.GDataService.__init__(
-        self, email=email, password=password, service='apps', source=source,
-        server=server, additional_headers=additional_headers, **kwargs)
-    self.ssl = True
-    self.port = 443
-    self.domain = domain
-
-  def _baseURL(self):
-    return "/a/feeds/%s" % self.domain 
-
-  def AddAllElementsFromAllPages(self, link_finder, func):
-    """retrieve all pages and add all elements"""
-    next = link_finder.GetNextLink()
-    while next is not None:
-      next_feed = self.Get(next.href, converter=func)
-      for a_entry in next_feed.entry:
-        link_finder.entry.append(a_entry)
-      next = next_feed.GetNextLink()
-    return link_finder
-
-  def RetrievePageOfEmailLists(self, start_email_list_name=None,
-                               num_retries=gdata.service.DEFAULT_NUM_RETRIES,
-                               delay=gdata.service.DEFAULT_DELAY,
-                               backoff=gdata.service.DEFAULT_BACKOFF):
-    """Retrieve one page of email list"""
-    uri = "%s/emailList/%s" % (self._baseURL(), API_VER)
-    if start_email_list_name is not None:
-      uri += "?startEmailListName=%s" % start_email_list_name
-    try:
-      return gdata.apps.EmailListFeedFromString(str(self.GetWithRetries(
-            uri, num_retries=num_retries, delay=delay, backoff=backoff)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-    
-  def GetGeneratorForAllEmailLists(
-    self, num_retries=gdata.service.DEFAULT_NUM_RETRIES,
-    delay=gdata.service.DEFAULT_DELAY, backoff=gdata.service.DEFAULT_BACKOFF):
-    """Retrieve a generator for all emaillists in this domain."""
-    first_page = self.RetrievePageOfEmailLists(num_retries=num_retries,
-                                               delay=delay,
-                                               backoff=backoff)
-    return self.GetGeneratorFromLinkFinder(
-      first_page, gdata.apps.EmailListRecipientFeedFromString,
-      num_retries=num_retries, delay=delay, backoff=backoff)
-
-  def RetrieveAllEmailLists(self):
-    """Retrieve all email list of a domain."""
-
-    ret = self.RetrievePageOfEmailLists()
-    # pagination
-    return self.AddAllElementsFromAllPages(
-      ret, gdata.apps.EmailListFeedFromString)
-
-  def RetrieveEmailList(self, list_name):
-    """Retreive a single email list by the list's name."""
-
-    uri = "%s/emailList/%s/%s" % (
-      self._baseURL(), API_VER, list_name)
-    try:
-      return self.Get(uri, converter=gdata.apps.EmailListEntryFromString)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def RetrieveEmailLists(self, recipient):
-    """Retrieve All Email List Subscriptions for an Email Address."""
-
-    uri = "%s/emailList/%s?recipient=%s" % (
-      self._baseURL(), API_VER, recipient)
-    try:
-      ret = gdata.apps.EmailListFeedFromString(str(self.Get(uri)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-    
-    # pagination
-    return self.AddAllElementsFromAllPages(
-      ret, gdata.apps.EmailListFeedFromString)
-
-  def RemoveRecipientFromEmailList(self, recipient, list_name):
-    """Remove recipient from email list."""
-    
-    uri = "%s/emailList/%s/%s/recipient/%s" % (
-      self._baseURL(), API_VER, list_name, recipient)
-    try:
-      self.Delete(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def RetrievePageOfRecipients(self, list_name, start_recipient=None,
-                               num_retries=gdata.service.DEFAULT_NUM_RETRIES,
-                               delay=gdata.service.DEFAULT_DELAY,
-                               backoff=gdata.service.DEFAULT_BACKOFF):
-    """Retrieve one page of recipient of an email list. """
-
-    uri = "%s/emailList/%s/%s/recipient" % (
-      self._baseURL(), API_VER, list_name)
-
-    if start_recipient is not None:
-      uri += "?startRecipient=%s" % start_recipient
-    try:
-      return gdata.apps.EmailListRecipientFeedFromString(str(
-          self.GetWithRetries(
-            uri, num_retries=num_retries, delay=delay, backoff=backoff)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def GetGeneratorForAllRecipients(
-    self, list_name, num_retries=gdata.service.DEFAULT_NUM_RETRIES,
-    delay=gdata.service.DEFAULT_DELAY, backoff=gdata.service.DEFAULT_BACKOFF):
-    """Retrieve a generator for all recipients of a particular emaillist."""
-    first_page = self.RetrievePageOfRecipients(list_name,
-                                               num_retries=num_retries,
-                                               delay=delay,
-                                               backoff=backoff)
-    return self.GetGeneratorFromLinkFinder(
-      first_page, gdata.apps.EmailListRecipientFeedFromString,
-      num_retries=num_retries, delay=delay, backoff=backoff)
-
-  def RetrieveAllRecipients(self, list_name):
-    """Retrieve all recipient of an email list."""
-
-    ret = self.RetrievePageOfRecipients(list_name)
-    # pagination
-    return self.AddAllElementsFromAllPages(
-      ret, gdata.apps.EmailListRecipientFeedFromString)
-
-  def AddRecipientToEmailList(self, recipient, list_name):
-    """Add a recipient to a email list."""
-
-    uri = "%s/emailList/%s/%s/recipient" % (
-      self._baseURL(), API_VER, list_name)
-    recipient_entry = gdata.apps.EmailListRecipientEntry()
-    recipient_entry.who = gdata.apps.Who(email=recipient)
-
-    try:
-      return gdata.apps.EmailListRecipientEntryFromString(
-        str(self.Post(recipient_entry, uri)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def DeleteEmailList(self, list_name):
-    """Delete a email list"""
-
-    uri = "%s/emailList/%s/%s" % (self._baseURL(), API_VER, list_name)
-    try:
-      self.Delete(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def CreateEmailList(self, list_name):
-    """Create a email list. """
-
-    uri = "%s/emailList/%s" % (self._baseURL(), API_VER)
-    email_list_entry = gdata.apps.EmailListEntry()
-    email_list_entry.email_list = gdata.apps.EmailList(name=list_name)
-    try: 
-      return gdata.apps.EmailListEntryFromString(
-        str(self.Post(email_list_entry, uri)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def DeleteNickname(self, nickname):
-    """Delete a nickname"""
-
-    uri = "%s/nickname/%s/%s" % (self._baseURL(), API_VER, nickname)
-    try:
-      self.Delete(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def RetrievePageOfNicknames(self, start_nickname=None,
-                              num_retries=gdata.service.DEFAULT_NUM_RETRIES,
-                              delay=gdata.service.DEFAULT_DELAY,
-                              backoff=gdata.service.DEFAULT_BACKOFF):
-    """Retrieve one page of nicknames in the domain"""
-
-    uri = "%s/nickname/%s" % (self._baseURL(), API_VER)
-    if start_nickname is not None:
-      uri += "?startNickname=%s" % start_nickname
-    try:
-      return gdata.apps.NicknameFeedFromString(str(self.GetWithRetries(
-            uri, num_retries=num_retries, delay=delay, backoff=backoff)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def GetGeneratorForAllNicknames(
-    self, num_retries=gdata.service.DEFAULT_NUM_RETRIES,
-    delay=gdata.service.DEFAULT_DELAY, backoff=gdata.service.DEFAULT_BACKOFF):
-    """Retrieve a generator for all nicknames in this domain."""
-    first_page = self.RetrievePageOfNicknames(num_retries=num_retries,
-                                              delay=delay,
-                                              backoff=backoff)
-    return self.GetGeneratorFromLinkFinder(
-      first_page, gdata.apps.NicknameFeedFromString, num_retries=num_retries,
-      delay=delay, backoff=backoff)
-
-  def RetrieveAllNicknames(self):
-    """Retrieve all nicknames in the domain"""
-
-    ret = self.RetrievePageOfNicknames()
-    # pagination
-    return self.AddAllElementsFromAllPages(
-      ret, gdata.apps.NicknameFeedFromString)
-
-  def GetGeneratorForAllNicknamesOfAUser(
-    self, user_name, num_retries=gdata.service.DEFAULT_NUM_RETRIES,
-    delay=gdata.service.DEFAULT_DELAY, backoff=gdata.service.DEFAULT_BACKOFF):
-    """Retrieve a generator for all nicknames of a particular user."""
-    uri = "%s/nickname/%s?username=%s" % (self._baseURL(), API_VER, user_name)
-    try:
-      first_page = gdata.apps.NicknameFeedFromString(str(self.GetWithRetries(
-            uri, num_retries=num_retries, delay=delay, backoff=backoff)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-    return self.GetGeneratorFromLinkFinder(
-      first_page, gdata.apps.NicknameFeedFromString, num_retries=num_retries,
-      delay=delay, backoff=backoff)
-
-  def RetrieveNicknames(self, user_name):
-    """Retrieve nicknames of the user"""
-
-    uri = "%s/nickname/%s?username=%s" % (self._baseURL(), API_VER, user_name)
-    try:
-      ret = gdata.apps.NicknameFeedFromString(str(self.Get(uri)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-    # pagination
-    return self.AddAllElementsFromAllPages(
-      ret, gdata.apps.NicknameFeedFromString)
-
-  def RetrieveNickname(self, nickname):
-    """Retrieve a nickname.
-
-    Args:
-      nickname: string The nickname to retrieve
-
-    Returns:
-      gdata.apps.NicknameEntry
-    """
-
-    uri = "%s/nickname/%s/%s" % (self._baseURL(), API_VER, nickname)
-    try:
-      return gdata.apps.NicknameEntryFromString(str(self.Get(uri)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def CreateNickname(self, user_name, nickname):
-    """Create a nickname"""
-
-    uri = "%s/nickname/%s" % (self._baseURL(), API_VER)
-    nickname_entry = gdata.apps.NicknameEntry()
-    nickname_entry.login = gdata.apps.Login(user_name=user_name)
-    nickname_entry.nickname = gdata.apps.Nickname(name=nickname)
-
-    try: 
-      return gdata.apps.NicknameEntryFromString(
-        str(self.Post(nickname_entry, uri)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def DeleteUser(self, user_name):
-    """Delete a user account"""
-
-    uri = "%s/user/%s/%s" % (self._baseURL(), API_VER, user_name)
-    try:
-      return self.Delete(uri)
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def UpdateUser(self, user_name, user_entry):
-    """Update a user account."""
-
-    uri = "%s/user/%s/%s" % (self._baseURL(), API_VER, user_name)
-    try: 
-      return gdata.apps.UserEntryFromString(str(self.Put(user_entry, uri)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def CreateUser(self, user_name, family_name, given_name, password,
-                 suspended='false', quota_limit=None, 
-                 password_hash_function=None,
-                 change_password=None):
-    """Create a user account. """
-
-    uri = "%s/user/%s" % (self._baseURL(), API_VER)
-    user_entry = gdata.apps.UserEntry()
-    user_entry.login = gdata.apps.Login(
-        user_name=user_name, password=password, suspended=suspended,
-        hash_function_name=password_hash_function,
-        change_password=change_password)
-    user_entry.name = gdata.apps.Name(family_name=family_name,
-                                      given_name=given_name)
-    if quota_limit is not None:
-      user_entry.quota = gdata.apps.Quota(limit=str(quota_limit))
-
-    try: 
-      return gdata.apps.UserEntryFromString(str(self.Post(user_entry, uri)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def SuspendUser(self, user_name):
-    user_entry = self.RetrieveUser(user_name)
-    if user_entry.login.suspended != 'true':
-      user_entry.login.suspended = 'true'
-      user_entry = self.UpdateUser(user_name, user_entry)
-    return user_entry
-
-  def RestoreUser(self, user_name):
-    user_entry = self.RetrieveUser(user_name)
-    if user_entry.login.suspended != 'false':
-      user_entry.login.suspended = 'false'
-      user_entry = self.UpdateUser(user_name, user_entry)
-    return user_entry
-
-  def RetrieveUser(self, user_name):
-    """Retrieve an user account.
-
-    Args:
-      user_name: string The user name to retrieve
-
-    Returns:
-      gdata.apps.UserEntry
-    """
-
-    uri = "%s/user/%s/%s" % (self._baseURL(), API_VER, user_name)
-    try:
-      return gdata.apps.UserEntryFromString(str(self.Get(uri)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def RetrievePageOfUsers(self, start_username=None,
-                          num_retries=gdata.service.DEFAULT_NUM_RETRIES,
-                          delay=gdata.service.DEFAULT_DELAY,
-                          backoff=gdata.service.DEFAULT_BACKOFF):
-    """Retrieve one page of users in this domain."""
-
-    uri = "%s/user/%s" % (self._baseURL(), API_VER)
-    if start_username is not None:
-      uri += "?startUsername=%s" % start_username
-    try:
-      return gdata.apps.UserFeedFromString(str(self.GetWithRetries(
-          uri, num_retries=num_retries, delay=delay, backoff=backoff)))
-    except gdata.service.RequestError, e:
-      raise AppsForYourDomainException(e.args[0])
-
-  def GetGeneratorForAllUsers(self,
-                              num_retries=gdata.service.DEFAULT_NUM_RETRIES,
-                              delay=gdata.service.DEFAULT_DELAY,
-                              backoff=gdata.service.DEFAULT_BACKOFF):
-    """Retrieve a generator for all users in this domain."""
-    first_page = self.RetrievePageOfUsers(num_retries=num_retries, delay=delay,
-                                          backoff=backoff)
-    return self.GetGeneratorFromLinkFinder(
-      first_page, gdata.apps.UserFeedFromString, num_retries=num_retries,
-      delay=delay, backoff=backoff)
-
-  def RetrieveAllUsers(self):
-    """Retrieve all users in this domain. OBSOLETE"""
-
-    ret = self.RetrievePageOfUsers()
-    # pagination
-    return self.AddAllElementsFromAllPages(
-      ret, gdata.apps.UserFeedFromString)
-
-
-class PropertyService(gdata.service.GDataService):
-  """Client for the Google Apps Property service."""
-
-  def __init__(self, email=None, password=None, domain=None, source=None,
-               server='apps-apis.google.com', additional_headers=None):
-    gdata.service.GDataService.__init__(self, email=email, password=password,
-                                        service='apps', source=source,
-                                        server=server,
-                                        additional_headers=additional_headers)
-    self.ssl = True
-    self.port = 443
-    self.domain = domain
-
-  def AddAllElementsFromAllPages(self, link_finder, func):
-    """retrieve all pages and add all elements"""
-    next = link_finder.GetNextLink()
-    count = 0
-    while next is not None:
-      next_feed = self.Get(next.href, converter=func)
-      count = count + len(next_feed.entry)
-      for a_entry in next_feed.entry:
-        link_finder.entry.append(a_entry)
-      next = next_feed.GetNextLink()
-    return link_finder
-
-  def _GetPropertyEntry(self, properties):
-    property_entry = gdata.apps.PropertyEntry()
-    property = []
-    for name, value in properties.iteritems():
-      if name is not None and value is not None:
-        property.append(gdata.apps.Property(name=name, value=value))
-    property_entry.property = property
-    return property_entry
-
-  def _PropertyEntry2Dict(self, property_entry):
-    properties = {}
-    for i, property in enumerate(property_entry.property):
-      properties[property.name] = property.value
-    return properties
-
-  def _GetPropertyFeed(self, uri):
-    try:
-      return gdata.apps.PropertyFeedFromString(str(self.Get(uri)))
-    except gdata.service.RequestError, e:
-      raise gdata.apps.service.AppsForYourDomainException(e.args[0])
-
-  def _GetPropertiesList(self, uri):
-    property_feed = self._GetPropertyFeed(uri)
-    # pagination
-    property_feed = self.AddAllElementsFromAllPages(
-      property_feed, gdata.apps.PropertyFeedFromString)
-    properties_list = []
-    for property_entry in property_feed.entry:
-      properties_list.append(self._PropertyEntry2Dict(property_entry))
-    return properties_list
-
-  def _GetProperties(self, uri):
-    try:
-      return self._PropertyEntry2Dict(gdata.apps.PropertyEntryFromString(
-        str(self.Get(uri))))
-    except gdata.service.RequestError, e:
-      raise gdata.apps.service.AppsForYourDomainException(e.args[0])
-
-  def _PostProperties(self, uri, properties):
-    property_entry = self._GetPropertyEntry(properties)
-    try:
-      return self._PropertyEntry2Dict(gdata.apps.PropertyEntryFromString(
-        str(self.Post(property_entry, uri))))
-    except gdata.service.RequestError, e:
-      raise gdata.apps.service.AppsForYourDomainException(e.args[0])
-
-  def _PutProperties(self, uri, properties):
-    property_entry = self._GetPropertyEntry(properties)
-    try:
-      return self._PropertyEntry2Dict(gdata.apps.PropertyEntryFromString(
-        str(self.Put(property_entry, uri))))
-    except gdata.service.RequestError, e:
-      raise gdata.apps.service.AppsForYourDomainException(e.args[0])
-
-  def _DeleteProperties(self, uri):
-    try:
-      self.Delete(uri)
-    except gdata.service.RequestError, e:
-      raise gdata.apps.service.AppsForYourDomainException(e.args[0])
-
-
-def _bool2str(b):
-  if b is None:
-    return None
-  return str(b is True).lower()

gdata/auth.py

@@ -1,952 +0,0 @@
-#!/usr/bin/python
-#
-# Copyright (C) 2007 - 2009 Google Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-import cgi
-import math
-import random
-import re
-import time
-import types
-import urllib
-import atom.http_interface
-import atom.token_store
-import atom.url
-import gdata.oauth as oauth
-import gdata.oauth.rsa as oauth_rsa
-import gdata.tlslite.utils.keyfactory as keyfactory
-import gdata.tlslite.utils.cryptomath as cryptomath
-
-import gdata.gauth
-
-__author__ = 'api.jscudder (Jeff Scudder)'
-
-
-PROGRAMMATIC_AUTH_LABEL = 'GoogleLogin auth='
-AUTHSUB_AUTH_LABEL = 'AuthSub token='
-
-
-"""This module provides functions and objects used with Google authentication.
-
-Details on Google authorization mechanisms used with the Google Data APIs can
-be found here: 
-http://code.google.com/apis/gdata/auth.html
-http://code.google.com/apis/accounts/
-
-The essential functions are the following.
-Related to ClientLogin:
-  generate_client_login_request_body: Constructs the body of an HTTP request to
-                                      obtain a ClientLogin token for a specific
-                                      service. 
-  extract_client_login_token: Creates a ClientLoginToken with the token from a
-                              success response to a ClientLogin request.
-  get_captcha_challenge: If the server responded to the ClientLogin request
-                         with a CAPTCHA challenge, this method extracts the
-                         CAPTCHA URL and identifying CAPTCHA token.
-
-Related to AuthSub:
-  generate_auth_sub_url: Constructs a full URL for a AuthSub request. The 
-                         user's browser must be sent to this Google Accounts
-                         URL and redirected back to the app to obtain the
-                         AuthSub token.
-  extract_auth_sub_token_from_url: Once the user's browser has been 
-                                   redirected back to the web app, use this
-                                   function to create an AuthSubToken with
-                                   the correct authorization token and scope.
-  token_from_http_body: Extracts the AuthSubToken value string from the 
-                        server's response to an AuthSub session token upgrade
-                        request.
-"""
-
-def generate_client_login_request_body(email, password, service, source, 
-    account_type='HOSTED_OR_GOOGLE', captcha_token=None, 
-    captcha_response=None):
-  """Creates the body of the autentication request
-
-  See http://code.google.com/apis/accounts/AuthForInstalledApps.html#Request
-  for more details.
-
-  Args:
-    email: str
-    password: str
-    service: str
-    source: str
-    account_type: str (optional) Defaul is 'HOSTED_OR_GOOGLE', other valid
-        values are 'GOOGLE' and 'HOSTED'
-    captcha_token: str (optional)
-    captcha_response: str (optional)
-
-  Returns:
-    The HTTP body to send in a request for a client login token.
-  """
-  return gdata.gauth.generate_client_login_request_body(email, password,
-      service, source, account_type, captcha_token, captcha_response)
-
-
-GenerateClientLoginRequestBody = generate_client_login_request_body
-
-
-def GenerateClientLoginAuthToken(http_body):
-  """Returns the token value to use in Authorization headers.
-
-  Reads the token from the server's response to a Client Login request and
-  creates header value to use in requests.
-
-  Args:
-    http_body: str The body of the server's HTTP response to a Client Login
-        request
- 
-  Returns:
-    The value half of an Authorization header.
-  """
-  token = get_client_login_token(http_body)
-  if token:
-    return 'GoogleLogin auth=%s' % token
-  return None
-
-
-def get_client_login_token(http_body):
-  """Returns the token value for a ClientLoginToken.
-
-  Reads the token from the server's response to a Client Login request and
-  creates the token value string to use in requests.
-
-  Args:
-    http_body: str The body of the server's HTTP response to a Client Login
-        request
- 
-  Returns:
-    The token value string for a ClientLoginToken.
-  """
-  return gdata.gauth.get_client_login_token_string(http_body)
-
-
-def extract_client_login_token(http_body, scopes):
-  """Parses the server's response and returns a ClientLoginToken.
-  
-  Args:
-    http_body: str The body of the server's HTTP response to a Client Login
-               request. It is assumed that the login request was successful.
-    scopes: list containing atom.url.Urls or strs. The scopes list contains
-            all of the partial URLs under which the client login token is
-            valid. For example, if scopes contains ['http://example.com/foo']
-            then the client login token would be valid for 
-            http://example.com/foo/bar/baz
-
-  Returns:
-    A ClientLoginToken which is valid for the specified scopes.
-  """
-  token_string = get_client_login_token(http_body)
-  token = ClientLoginToken(scopes=scopes)
-  token.set_token_string(token_string)
-  return token
-
-
-def get_captcha_challenge(http_body, 
-    captcha_base_url='http://www.google.com/accounts/'):
-  """Returns the URL and token for a CAPTCHA challenge issued by the server.
-
-  Args:
-    http_body: str The body of the HTTP response from the server which 
-        contains the CAPTCHA challenge.
-    captcha_base_url: str This function returns a full URL for viewing the 
-        challenge image which is built from the server's response. This
-        base_url is used as the beginning of the URL because the server
-        only provides the end of the URL. For example the server provides
-        'Captcha?ctoken=Hi...N' and the URL for the image is
-        'http://www.google.com/accounts/Captcha?ctoken=Hi...N'
-
-  Returns:
-    A dictionary containing the information needed to repond to the CAPTCHA
-    challenge, the image URL and the ID token of the challenge. The 
-    dictionary is in the form:
-    {'token': string identifying the CAPTCHA image,
-     'url': string containing the URL of the image}
-    Returns None if there was no CAPTCHA challenge in the response.
-  """
-  return gdata.gauth.get_captcha_challenge(http_body, captcha_base_url)
-
-
-GetCaptchaChallenge = get_captcha_challenge
-
-
-def GenerateOAuthRequestTokenUrl(
-    oauth_input_params, scopes,
-    request_token_url='https://www.google.com/accounts/OAuthGetRequestToken',
-    extra_parameters=None):
-  """Generate a URL at which a request for OAuth request token is to be sent.
-  
-  Args:
-    oauth_input_params: OAuthInputParams OAuth input parameters.
-    scopes: list of strings The URLs of the services to be accessed.
-    request_token_url: string The beginning of the request token URL. This is
-        normally 'https://www.google.com/accounts/OAuthGetRequestToken' or
-        '/accounts/OAuthGetRequestToken'
-    extra_parameters: dict (optional) key-value pairs as any additional
-        parameters to be included in the URL and signature while making a
-        request for fetching an OAuth request token. All the OAuth parameters
-        are added by default. But if provided through this argument, any
-        default parameters will be overwritten. For e.g. a default parameter
-        oauth_version 1.0 can be overwritten if
-        extra_parameters = {'oauth_version': '2.0'}
-  
-  Returns:
-    atom.url.Url OAuth request token URL.
-  """
-  scopes_string = ' '.join([str(scope) for scope in scopes])
-  parameters = {'scope': scopes_string}
-  if extra_parameters:
-    parameters.update(extra_parameters)
-  oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-      oauth_input_params.GetConsumer(), http_url=request_token_url,
-      parameters=parameters)
-  oauth_request.sign_request(oauth_input_params.GetSignatureMethod(),
-                             oauth_input_params.GetConsumer(), None)
-  return atom.url.parse_url(oauth_request.to_url())
-
-
-def GenerateOAuthAuthorizationUrl(
-    request_token,
-    authorization_url='https://www.google.com/accounts/OAuthAuthorizeToken',
-    callback_url=None, extra_params=None,
-    include_scopes_in_callback=False, scopes_param_prefix='oauth_token_scope'):
-  """Generates URL at which user will login to authorize the request token.
-  
-  Args:
-    request_token: gdata.auth.OAuthToken OAuth request token.
-    authorization_url: string The beginning of the authorization URL. This is
-        normally 'https://www.google.com/accounts/OAuthAuthorizeToken' or
-        '/accounts/OAuthAuthorizeToken'
-    callback_url: string (optional) The URL user will be sent to after
-        logging in and granting access.
-    extra_params: dict (optional) Additional parameters to be sent.
-    include_scopes_in_callback: Boolean (default=False) if set to True, and
-        if 'callback_url' is present, the 'callback_url' will be modified to
-        include the scope(s) from the request token as a URL parameter. The
-        key for the 'callback' URL's scope parameter will be
-        OAUTH_SCOPE_URL_PARAM_NAME. The benefit of including the scope URL as
-        a parameter to the 'callback' URL, is that the page which receives
-        the OAuth token will be able to tell which URLs the token grants
-        access to.
-    scopes_param_prefix: string (default='oauth_token_scope') The URL
-        parameter key which maps to the list of valid scopes for the token.
-        This URL parameter will be included in the callback URL along with
-        the scopes of the token as value if include_scopes_in_callback=True.
-
-  Returns:
-    atom.url.Url OAuth authorization URL.
-  """
-  scopes = request_token.scopes
-  if isinstance(scopes, list):
-    scopes = ' '.join(scopes)  
-  if include_scopes_in_callback and callback_url:
-    if callback_url.find('?') > -1:
-      callback_url += '&'
-    else:
-      callback_url += '?'
-    callback_url += urllib.urlencode({scopes_param_prefix:scopes})  
-  oauth_token = oauth.OAuthToken(request_token.key, request_token.secret)
-  oauth_request = oauth.OAuthRequest.from_token_and_callback(
-      token=oauth_token, callback=callback_url,
-      http_url=authorization_url, parameters=extra_params)
-  return atom.url.parse_url(oauth_request.to_url())
-
-
-def GenerateOAuthAccessTokenUrl(
-    authorized_request_token,
-    oauth_input_params,
-    access_token_url='https://www.google.com/accounts/OAuthGetAccessToken',
-    oauth_version='1.0',
-    oauth_verifier=None):
-  """Generates URL at which user will login to authorize the request token.
-  
-  Args:
-    authorized_request_token: gdata.auth.OAuthToken OAuth authorized request
-        token.
-    oauth_input_params: OAuthInputParams OAuth input parameters.    
-    access_token_url: string The beginning of the authorization URL. This is
-        normally 'https://www.google.com/accounts/OAuthGetAccessToken' or
-        '/accounts/OAuthGetAccessToken'
-    oauth_version: str (default='1.0') oauth_version parameter.
-    oauth_verifier: str (optional) If present, it is assumed that the client
-        will use the OAuth v1.0a protocol which includes passing the
-        oauth_verifier (as returned by the SP) in the access token step.
-
-  Returns:
-    atom.url.Url OAuth access token URL.
-  """
-  oauth_token = oauth.OAuthToken(authorized_request_token.key,
-                                 authorized_request_token.secret)
-  parameters = {'oauth_version': oauth_version}
-  if oauth_verifier is not None:
-    parameters['oauth_verifier'] = oauth_verifier
-  oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-      oauth_input_params.GetConsumer(), token=oauth_token,
-      http_url=access_token_url, parameters=parameters)
-  oauth_request.sign_request(oauth_input_params.GetSignatureMethod(),
-                             oauth_input_params.GetConsumer(), oauth_token)
-  return atom.url.parse_url(oauth_request.to_url())
-
-
-def GenerateAuthSubUrl(next, scope, secure=False, session=True, 
-    request_url='https://www.google.com/accounts/AuthSubRequest',
-    domain='default'):
-  """Generate a URL at which the user will login and be redirected back.
-
-  Users enter their credentials on a Google login page and a token is sent
-  to the URL specified in next. See documentation for AuthSub login at:
-  http://code.google.com/apis/accounts/AuthForWebApps.html
-
-  Args:
-    request_url: str The beginning of the request URL. This is normally
-        'http://www.google.com/accounts/AuthSubRequest' or 
-        '/accounts/AuthSubRequest'
-    next: string The URL user will be sent to after logging in.
-    scope: string The URL of the service to be accessed.
-    secure: boolean (optional) Determines whether or not the issued token
-            is a secure token.
-    session: boolean (optional) Determines whether or not the issued token
-             can be upgraded to a session token.
-    domain: str (optional) The Google Apps domain for this account. If this
-            is not a Google Apps account, use 'default' which is the default
-            value.
-  """
-  # Translate True/False values for parameters into numeric values acceoted
-  # by the AuthSub service.
-  if secure:
-    secure = 1
-  else:
-    secure = 0
-
-  if session:
-    session = 1
-  else:
-    session = 0
-
-  request_params = urllib.urlencode({'next': next, 'scope': scope,
-                                     'secure': secure, 'session': session, 
-                                     'hd': domain})
-  if request_url.find('?') == -1:
-    return '%s?%s' % (request_url, request_params)
-  else:
-    # The request URL already contained url parameters so we should add
-    # the parameters using the & seperator
-    return '%s&%s' % (request_url, request_params)
-
-
-def generate_auth_sub_url(next, scopes, secure=False, session=True,
-    request_url='https://www.google.com/accounts/AuthSubRequest', 
-    domain='default', scopes_param_prefix='auth_sub_scopes'):
-  """Constructs a URL string for requesting a multiscope AuthSub token.
-
-  The generated token will contain a URL parameter to pass along the 
-  requested scopes to the next URL. When the Google Accounts page 
-  redirects the broswser to the 'next' URL, it appends the single use
-  AuthSub token value to the URL as a URL parameter with the key 'token'.
-  However, the information about which scopes were requested is not
-  included by Google Accounts. This method adds the scopes to the next
-  URL before making the request so that the redirect will be sent to 
-  a page, and both the token value and the list of scopes can be 
-  extracted from the request URL. 
-
-  Args:
-    next: atom.url.URL or string The URL user will be sent to after
-          authorizing this web application to access their data.
-    scopes: list containint strings The URLs of the services to be accessed.
-    secure: boolean (optional) Determines whether or not the issued token
-            is a secure token.
-    session: boolean (optional) Determines whether or not the issued token
-             can be upgraded to a session token.
-    request_url: atom.url.Url or str The beginning of the request URL. This
-        is normally 'http://www.google.com/accounts/AuthSubRequest' or 
-        '/accounts/AuthSubRequest'
-    domain: The domain which the account is part of. This is used for Google
-        Apps accounts, the default value is 'default' which means that the
-        requested account is a Google Account (@gmail.com for example)
-    scopes_param_prefix: str (optional) The requested scopes are added as a 
-        URL parameter to the next URL so that the page at the 'next' URL can
-        extract the token value and the valid scopes from the URL. The key
-        for the URL parameter defaults to 'auth_sub_scopes'
-
-  Returns:
-    An atom.url.Url which the user's browser should be directed to in order
-    to authorize this application to access their information.
-  """
-  if isinstance(next, (str, unicode)):
-    next = atom.url.parse_url(next)
-  scopes_string = ' '.join([str(scope) for scope in scopes])
-  next.params[scopes_param_prefix] = scopes_string
-
-  if isinstance(request_url, (str, unicode)):
-    request_url = atom.url.parse_url(request_url)
-  request_url.params['next'] = str(next)
-  request_url.params['scope'] = scopes_string
-  if session:
-    request_url.params['session'] = 1
-  else:
-    request_url.params['session'] = 0
-  if secure:
-    request_url.params['secure'] = 1
-  else:
-    request_url.params['secure'] = 0
-  request_url.params['hd'] = domain
-  return request_url
-
-
-def AuthSubTokenFromUrl(url):
-  """Extracts the AuthSub token from the URL. 
-
-  Used after the AuthSub redirect has sent the user to the 'next' page and
-  appended the token to the URL. This function returns the value to be used
-  in the Authorization header. 
-
-  Args:
-    url: str The URL of the current page which contains the AuthSub token as
-        a URL parameter.
-  """
-  token = TokenFromUrl(url)
-  if token:
-    return 'AuthSub token=%s' % token
-  return None
-
-
-def TokenFromUrl(url):
-  """Extracts the AuthSub token from the URL.
-
-  Returns the raw token value.
-
-  Args:
-    url: str The URL or the query portion of the URL string (after the ?) of
-        the current page which contains the AuthSub token as a URL parameter.
-  """
-  if url.find('?') > -1:
-    query_params = url.split('?')[1]
-  else:
-    query_params = url
-  for pair in query_params.split('&'):
-    if pair.startswith('token='):
-      return pair[6:]
-  return None
-
-
-def extract_auth_sub_token_from_url(url, 
-    scopes_param_prefix='auth_sub_scopes', rsa_key=None):
-  """Creates an AuthSubToken and sets the token value and scopes from the URL.
-  
-  After the Google Accounts AuthSub pages redirect the user's broswer back to 
-  the web application (using the 'next' URL from the request) the web app must
-  extract the token from the current page's URL. The token is provided as a 
-  URL parameter named 'token' and if generate_auth_sub_url was used to create
-  the request, the token's valid scopes are included in a URL parameter whose
-  name is specified in scopes_param_prefix.
-
-  Args:
-    url: atom.url.Url or str representing the current URL. The token value
-         and valid scopes should be included as URL parameters.
-    scopes_param_prefix: str (optional) The URL parameter key which maps to
-                         the list of valid scopes for the token.
-
-  Returns:
-    An AuthSubToken with the token value from the URL and set to be valid for
-    the scopes passed in on the URL. If no scopes were included in the URL,
-    the AuthSubToken defaults to being valid for no scopes. If there was no
-    'token' parameter in the URL, this function returns None.
-  """
-  if isinstance(url, (str, unicode)):
-    url = atom.url.parse_url(url)
-  if 'token' not in url.params:
-    return None
-  scopes = []
-  if scopes_param_prefix in url.params:
-    scopes = url.params[scopes_param_prefix].split(' ')
-  token_value = url.params['token']
-  if rsa_key:
-    token = SecureAuthSubToken(rsa_key, scopes=scopes)
-  else:
-    token = AuthSubToken(scopes=scopes)
-  token.set_token_string(token_value)
-  return token
-
-
-def AuthSubTokenFromHttpBody(http_body):
-  """Extracts the AuthSub token from an HTTP body string.
-
-  Used to find the new session token after making a request to upgrade a
-  single use AuthSub token.
-
-  Args:
-    http_body: str The repsonse from the server which contains the AuthSub
-        key. For example, this function would find the new session token
-        from the server's response to an upgrade token request.
-
-  Returns:
-    The header value to use for Authorization which contains the AuthSub
-    token.
-  """
-  token_value = token_from_http_body(http_body)
-  if token_value:
-    return '%s%s' % (AUTHSUB_AUTH_LABEL, token_value)
-  return None
-
-
-def token_from_http_body(http_body):
-  """Extracts the AuthSub token from an HTTP body string.
-
-  Used to find the new session token after making a request to upgrade a 
-  single use AuthSub token.
-
-  Args:
-    http_body: str The repsonse from the server which contains the AuthSub 
-        key. For example, this function would find the new session token
-        from the server's response to an upgrade token request.
-
-  Returns:
-    The raw token value to use in an AuthSubToken object.
-  """
-  for response_line in http_body.splitlines():
-    if response_line.startswith('Token='):
-      # Strip off Token= and return the token value string.
-      return response_line[6:]
-  return None
-
-
-TokenFromHttpBody = token_from_http_body
-
-
-def OAuthTokenFromUrl(url, scopes_param_prefix='oauth_token_scope'):
-  """Creates an OAuthToken and sets token key and scopes (if present) from URL.
-  
-  After the Google Accounts OAuth pages redirect the user's broswer back to 
-  the web application (using the 'callback' URL from the request) the web app
-  can extract the token from the current page's URL. The token is same as the
-  request token, but it is either authorized (if user grants access) or
-  unauthorized (if user denies access). The token is provided as a 
-  URL parameter named 'oauth_token' and if it was chosen to use
-  GenerateOAuthAuthorizationUrl with include_scopes_in_param=True, the token's
-  valid scopes are included in a URL parameter whose name is specified in
-  scopes_param_prefix.
-
-  Args:
-    url: atom.url.Url or str representing the current URL. The token value
-        and valid scopes should be included as URL parameters.
-    scopes_param_prefix: str (optional) The URL parameter key which maps to
-        the list of valid scopes for the token.
-
-  Returns:
-    An OAuthToken with the token key from the URL and set to be valid for
-    the scopes passed in on the URL. If no scopes were included in the URL,
-    the OAuthToken defaults to being valid for no scopes. If there was no
-    'oauth_token' parameter in the URL, this function returns None.
-  """
-  if isinstance(url, (str, unicode)):
-    url = atom.url.parse_url(url)
-  if 'oauth_token' not in url.params:
-    return None
-  scopes = []
-  if scopes_param_prefix in url.params:
-    scopes = url.params[scopes_param_prefix].split(' ')
-  token_key = url.params['oauth_token']
-  token = OAuthToken(key=token_key, scopes=scopes)
-  return token
-
-
-def OAuthTokenFromHttpBody(http_body):
-  """Parses the HTTP response body and returns an OAuth token.
-  
-  The returned OAuth token will just have key and secret parameters set.
-  It won't have any knowledge about the scopes or oauth_input_params. It is
-  your responsibility to make it aware of the remaining parameters.
-  
-  Returns:
-    OAuthToken OAuth token.
-  """
-  token = oauth.OAuthToken.from_string(http_body)
-  oauth_token = OAuthToken(key=token.key, secret=token.secret)
-  return oauth_token
-  
-
-class OAuthSignatureMethod(object):
-  """Holds valid OAuth signature methods.
-  
-  RSA_SHA1: Class to build signature according to RSA-SHA1 algorithm.
-  HMAC_SHA1: Class to build signature according to HMAC-SHA1 algorithm.
-  """
-  
-  HMAC_SHA1 = oauth.OAuthSignatureMethod_HMAC_SHA1  
-  
-  class RSA_SHA1(oauth_rsa.OAuthSignatureMethod_RSA_SHA1):
-    """Provides implementation for abstract methods to return RSA certs."""
-
-    def __init__(self, private_key, public_cert):
-      self.private_key = private_key
-      self.public_cert = public_cert
-  
-    def _fetch_public_cert(self, unused_oauth_request):
-      return self.public_cert
-  
-    def _fetch_private_cert(self, unused_oauth_request):
-      return self.private_key
-  
-
-class OAuthInputParams(object):
-  """Stores OAuth input parameters.
-  
-  This class is a store for OAuth input parameters viz. consumer key and secret,
-  signature method and RSA key.
-  """
-  
-  def __init__(self, signature_method, consumer_key, consumer_secret=None,
-               rsa_key=None, requestor_id=None):
-    """Initializes object with parameters required for using OAuth mechanism.
-    
-    NOTE: Though consumer_secret and rsa_key are optional, either of the two
-    is required depending on the value of the signature_method.
-    
-    Args:
-      signature_method: class which provides implementation for strategy class
-          oauth.oauth.OAuthSignatureMethod. Signature method to be used for
-          signing each request. Valid implementations are provided as the
-          constants defined by gdata.auth.OAuthSignatureMethod. Currently
-          they are gdata.auth.OAuthSignatureMethod.RSA_SHA1 and
-          gdata.auth.OAuthSignatureMethod.HMAC_SHA1. Instead of passing in
-          the strategy class, you may pass in a string for 'RSA_SHA1' or 
-          'HMAC_SHA1'. If you plan to use OAuth on App Engine (or another
-          WSGI environment) I recommend specifying signature method using a
-          string (the only options are 'RSA_SHA1' and 'HMAC_SHA1'). In these
-          environments there are sometimes issues with pickling an object in 
-          which a member references a class or function. Storing a string to
-          refer to the signature method mitigates complications when
-          pickling.
-      consumer_key: string Domain identifying third_party web application.
-      consumer_secret: string (optional) Secret generated during registration.
-          Required only for HMAC_SHA1 signature method.
-      rsa_key: string (optional) Private key required for RSA_SHA1 signature
-          method.
-      requestor_id: string (optional) User email adress to make requests on
-          their behalf.  This parameter should only be set when performing
-          2 legged OAuth requests.
-    """
-    if (signature_method == OAuthSignatureMethod.RSA_SHA1
-        or signature_method == 'RSA_SHA1'):
-      self.__signature_strategy = 'RSA_SHA1'
-    elif (signature_method == OAuthSignatureMethod.HMAC_SHA1
-        or signature_method == 'HMAC_SHA1'):
-      self.__signature_strategy = 'HMAC_SHA1'
-    else:
-      self.__signature_strategy = signature_method
-    self.rsa_key = rsa_key
-    self._consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
-    self.requestor_id = requestor_id
-
-  def __get_signature_method(self):
-    if self.__signature_strategy == 'RSA_SHA1':
-      return OAuthSignatureMethod.RSA_SHA1(self.rsa_key, None)
-    elif self.__signature_strategy == 'HMAC_SHA1':
-      return OAuthSignatureMethod.HMAC_SHA1()
-    else:
-      return self.__signature_strategy()
-
-  def __set_signature_method(self, signature_method):
-    if (signature_method == OAuthSignatureMethod.RSA_SHA1
-        or signature_method == 'RSA_SHA1'):
-      self.__signature_strategy = 'RSA_SHA1'
-    elif (signature_method == OAuthSignatureMethod.HMAC_SHA1
-        or signature_method == 'HMAC_SHA1'):
-      self.__signature_strategy = 'HMAC_SHA1'
-    else:
-      self.__signature_strategy = signature_method
-
-  _signature_method = property(__get_signature_method, __set_signature_method,
-      doc="""Returns object capable of signing the request using RSA of HMAC.
-      
-      Replaces the _signature_method member to avoid pickle errors.""")
-
-  def GetSignatureMethod(self):
-    """Gets the OAuth signature method.
-
-    Returns:
-      object of supertype <oauth.oauth.OAuthSignatureMethod>
-    """
-    return self._signature_method
-
-  def GetConsumer(self):
-    """Gets the OAuth consumer.
-
-    Returns:
-      object of type <oauth.oauth.Consumer>
-    """
-    return self._consumer
-
-
-class ClientLoginToken(atom.http_interface.GenericToken):
-  """Stores the Authorization header in auth_header and adds to requests.
-
-  This token will add it's Authorization header to an HTTP request
-  as it is made. Ths token class is simple but
-  some Token classes must calculate portions of the Authorization header
-  based on the request being made, which is why the token is responsible
-  for making requests via an http_client parameter.
-
-  Args:
-    auth_header: str The value for the Authorization header.
-    scopes: list of str or atom.url.Url specifying the beginnings of URLs
-        for which this token can be used. For example, if scopes contains
-        'http://example.com/foo', then this token can be used for a request to
-        'http://example.com/foo/bar' but it cannot be used for a request to
-        'http://example.com/baz'
-  """
-  def __init__(self, auth_header=None, scopes=None):
-    self.auth_header = auth_header
-    self.scopes = scopes or []
-
-  def __str__(self):
-    return self.auth_header
-
-  def perform_request(self, http_client, operation, url, data=None,
-                      headers=None):
-    """Sets the Authorization header and makes the HTTP request."""
-    if headers is None:
-      headers = {'Authorization':self.auth_header}
-    else:
-      headers['Authorization'] = self.auth_header
-    return http_client.request(operation, url, data=data, headers=headers)
-
-  def get_token_string(self):
-    """Removes PROGRAMMATIC_AUTH_LABEL to give just the token value."""
-    return self.auth_header[len(PROGRAMMATIC_AUTH_LABEL):]
-
-  def set_token_string(self, token_string):
-    self.auth_header = '%s%s' % (PROGRAMMATIC_AUTH_LABEL, token_string)
-  
-  def valid_for_scope(self, url):
-    """Tells the caller if the token authorizes access to the desired URL.
-    """
-    if isinstance(url, (str, unicode)):
-      url = atom.url.parse_url(url)
-    for scope in self.scopes:
-      if scope == atom.token_store.SCOPE_ALL:
-        return True
-      if isinstance(scope, (str, unicode)):
-        scope = atom.url.parse_url(scope)
-      if scope == url:
-        return True
-      # Check the host and the path, but ignore the port and protocol.
-      elif scope.host == url.host and not scope.path:
-        return True
-      elif scope.host == url.host and scope.path and not url.path:
-        continue
-      elif scope.host == url.host and url.path.startswith(scope.path):
-        return True
-    return False
-
-
-class AuthSubToken(ClientLoginToken):
-  def get_token_string(self):
-    """Removes AUTHSUB_AUTH_LABEL to give just the token value."""
-    return self.auth_header[len(AUTHSUB_AUTH_LABEL):]
-
-  def set_token_string(self, token_string):
-    self.auth_header = '%s%s' % (AUTHSUB_AUTH_LABEL, token_string)
-
-
-class OAuthToken(atom.http_interface.GenericToken):
-  """Stores the token key, token secret and scopes for which token is valid.
-  
-  This token adds the authorization header to each request made. It
-  re-calculates authorization header for every request since the OAuth
-  signature to be added to the authorization header is dependent on the
-  request parameters.
-  
-  Attributes:
-    key: str The value for the OAuth token i.e. token key.
-    secret: str The value for the OAuth token secret.
-    scopes: list of str or atom.url.Url specifying the beginnings of URLs
-        for which this token can be used. For example, if scopes contains
-        'http://example.com/foo', then this token can be used for a request to
-        'http://example.com/foo/bar' but it cannot be used for a request to
-        'http://example.com/baz'
-    oauth_input_params: OAuthInputParams OAuth input parameters.      
-  """
-  
-  def __init__(self, key=None, secret=None, scopes=None,
-               oauth_input_params=None):
-    self.key = key
-    self.secret = secret
-    self.scopes = scopes or []
-    self.oauth_input_params = oauth_input_params
-  
-  def __str__(self):
-    return self.get_token_string()
-
-  def get_token_string(self):
-    """Returns the token string.
-    
-    The token string returned is of format
-    oauth_token=[0]&oauth_token_secret=[1], where [0] and [1] are some strings.
-    
-    Returns:
-      A token string of format oauth_token=[0]&oauth_token_secret=[1],
-      where [0] and [1] are some strings. If self.secret is absent, it just
-      returns oauth_token=[0]. If self.key is absent, it just returns
-      oauth_token_secret=[1]. If both are absent, it returns None.
-    """
-    if self.key and self.secret:
-      return urllib.urlencode({'oauth_token': self.key,
-                               'oauth_token_secret': self.secret})
-    elif self.key:
-      return 'oauth_token=%s' % self.key
-    elif self.secret:
-      return 'oauth_token_secret=%s' % self.secret
-    else:
-      return None
-
-  def set_token_string(self, token_string):
-    """Sets the token key and secret from the token string.
-    
-    Args:
-      token_string: str Token string of form
-          oauth_token=[0]&oauth_token_secret=[1]. If oauth_token is not present,
-          self.key will be None. If oauth_token_secret is not present,
-          self.secret will be None.
-    """
-    token_params = cgi.parse_qs(token_string, keep_blank_values=False)
-    if 'oauth_token' in token_params:
-      self.key = token_params['oauth_token'][0]
-    if 'oauth_token_secret' in token_params:
-      self.secret = token_params['oauth_token_secret'][0]
-    
-  def GetAuthHeader(self, http_method, http_url, realm=''):
-    """Get the authentication header.
-
-    Args:
-      http_method: string HTTP method i.e. operation e.g. GET, POST, PUT, etc.
-      http_url: string or atom.url.Url HTTP URL to which request is made.
-      realm: string (default='') realm parameter to be included in the
-          authorization header.
-
-    Returns:
-      dict Header to be sent with every subsequent request after
-      authentication.
-    """
-    if isinstance(http_url, types.StringTypes):
-      http_url = atom.url.parse_url(http_url)
-    header = None
-    token = None
-    if self.key or self.secret:
-      token = oauth.OAuthToken(self.key, self.secret)
-    oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-        self.oauth_input_params.GetConsumer(), token=token,
-        http_url=str(http_url), http_method=http_method,
-        parameters=http_url.params)
-    oauth_request.sign_request(self.oauth_input_params.GetSignatureMethod(),
-                               self.oauth_input_params.GetConsumer(), token)
-    header = oauth_request.to_header(realm=realm)
-    header['Authorization'] = header['Authorization'].replace('+', '%2B')
-    return header
-  
-  def perform_request(self, http_client, operation, url, data=None,
-                      headers=None):
-    """Sets the Authorization header and makes the HTTP request."""
-    if not headers:
-      headers = {}
-    if self.oauth_input_params.requestor_id:
-      url.params['xoauth_requestor_id'] = self.oauth_input_params.requestor_id
-    headers.update(self.GetAuthHeader(operation, url))
-    return http_client.request(operation, url, data=data, headers=headers)
-    
-  def valid_for_scope(self, url):
-    if isinstance(url, (str, unicode)):
-      url = atom.url.parse_url(url)
-    for scope in self.scopes:
-      if scope == atom.token_store.SCOPE_ALL:
-        return True
-      if isinstance(scope, (str, unicode)):
-        scope = atom.url.parse_url(scope)
-      if scope == url:
-        return True
-      # Check the host and the path, but ignore the port and protocol.
-      elif scope.host == url.host and not scope.path:
-        return True
-      elif scope.host == url.host and scope.path and not url.path:
-        continue
-      elif scope.host == url.host and url.path.startswith(scope.path):
-        return True
-    return False    
-    
-
-class SecureAuthSubToken(AuthSubToken):
-  """Stores the rsa private key, token, and scopes for the secure AuthSub token.
-  
-  This token adds the authorization header to each request made. It
-  re-calculates authorization header for every request since the secure AuthSub
-  signature to be added to the authorization header is dependent on the
-  request parameters.
-  
-  Attributes:
-    rsa_key: string The RSA private key in PEM format that the token will
-             use to sign requests
-    token_string: string (optional) The value for the AuthSub token.
-    scopes: list of str or atom.url.Url specifying the beginnings of URLs
-        for which this token can be used. For example, if scopes contains
-        'http://example.com/foo', then this token can be used for a request to
-        'http://example.com/foo/bar' but it cannot be used for a request to
-        'http://example.com/baz'     
-  """
-  
-  def __init__(self, rsa_key, token_string=None, scopes=None):
-    self.rsa_key = keyfactory.parsePEMKey(rsa_key)
-    self.token_string = token_string or ''
-    self.scopes = scopes or [] 
-   
-  def __str__(self):
-    return self.get_token_string()
-
-  def get_token_string(self):
-    return str(self.token_string)
-
-  def set_token_string(self, token_string):
-    self.token_string = token_string
-    
-  def GetAuthHeader(self, http_method, http_url):
-    """Generates the Authorization header.
-
-    The form of the secure AuthSub Authorization header is
-    Authorization: AuthSub token="token" sigalg="sigalg" data="data" sig="sig"
-    and  data represents a string in the form
-    data = http_method http_url timestamp nonce
-
-    Args:
-      http_method: string HTTP method i.e. operation e.g. GET, POST, PUT, etc.
-      http_url: string or atom.url.Url HTTP URL to which request is made.
-      
-    Returns:
-      dict Header to be sent with every subsequent request after authentication.
-    """
-    timestamp = int(math.floor(time.time()))
-    nonce = '%lu' % random.randrange(1, 2**64)
-    data = '%s %s %d %s' % (http_method, str(http_url), timestamp, nonce)
-    sig = cryptomath.bytesToBase64(self.rsa_key.hashAndSign(data))
-    header = {'Authorization': '%s"%s" data="%s" sig="%s" sigalg="rsa-sha1"' %
-              (AUTHSUB_AUTH_LABEL, self.token_string, data, sig)}
-    return header
-  
-  def perform_request(self, http_client, operation, url, data=None, 
-                      headers=None):
-    """Sets the Authorization header and makes the HTTP request."""
-    if not headers:
-      headers = {}
-    headers.update(self.GetAuthHeader(operation, url))
-    return http_client.request(operation, url, data=data, headers=headers)

gdata/oauth/CHANGES.txt

@@ -1,17 +0,0 @@
-1. Moved oauth.py to __init__.py
-
-2. Refactored __init__.py for compatibility with python 2.2 (Issue 59)
-
-3. Refactored rsa.py for compatibility with python 2.2 (Issue 59)
-
-4. Refactored OAuthRequest.from_token_and_callback since the callback url was
-getting double url-encoding the callback url in place of single. (Issue 43)
-
-5. Added build_signature_base_string method to rsa.py since it used the
-implementation of this method from oauth.OAuthSignatureMethod_HMAC_SHA1 which
-was incorrect since it enforced the presence of a consumer secret and a token
-secret. Also, changed its super class from oauth.OAuthSignatureMethod_HMAC_SHA1
-to oauth.OAuthSignatureMethod (Issue 64)
-
-6. Refactored <OAuthRequest>.to_header method since it returned non-oauth params
-as well which was incorrect. (Issue 31)

gdata/oauth/__init__.py

@@ -1,524 +0,0 @@
-import cgi
-import urllib
-import time
-import random
-import urlparse
-import hmac
-import binascii
-
-VERSION = '1.0' # Hi Blaine!
-HTTP_METHOD = 'GET'
-SIGNATURE_METHOD = 'PLAINTEXT'
-
-# Generic exception class
-class OAuthError(RuntimeError):
-    def __init__(self, message='OAuth error occured.'):
-        self.message = message
-
-# optional WWW-Authenticate header (401 error)
-def build_authenticate_header(realm=''):
-    return {'WWW-Authenticate': 'OAuth realm="%s"' % realm}
-
-# url escape
-def escape(s):
-    # escape '/' too
-    return urllib.quote(s, safe='~')
-
-# util function: current timestamp
-# seconds since epoch (UTC)
-def generate_timestamp():
-    return int(time.time())
-
-# util function: nonce
-# pseudorandom number
-def generate_nonce(length=8):
-    return ''.join([str(random.randint(0, 9)) for i in range(length)])
-
-# OAuthConsumer is a data type that represents the identity of the Consumer
-# via its shared secret with the Service Provider.
-class OAuthConsumer(object):
-    key = None
-    secret = None
-
-    def __init__(self, key, secret):
-        self.key = key
-        self.secret = secret
-
-# OAuthToken is a data type that represents an End User via either an access
-# or request token.     
-class OAuthToken(object):
-    # access tokens and request tokens
-    key = None
-    secret = None
-
-    '''
-    key = the token
-    secret = the token secret
-    '''
-    def __init__(self, key, secret):
-        self.key = key
-        self.secret = secret
-
-    def to_string(self):
-        return urllib.urlencode({'oauth_token': self.key, 'oauth_token_secret': self.secret})
-
-    # return a token from something like:
-    # oauth_token_secret=digg&oauth_token=digg
-    def from_string(s):
-        params = cgi.parse_qs(s, keep_blank_values=False)
-        key = params['oauth_token'][0]
-        secret = params['oauth_token_secret'][0]
-        return OAuthToken(key, secret)
-    from_string = staticmethod(from_string)
-
-    def __str__(self):
-        return self.to_string()
-
-# OAuthRequest represents the request and can be serialized
-class OAuthRequest(object):
-    '''
-    OAuth parameters:
-        - oauth_consumer_key 
-        - oauth_token
-        - oauth_signature_method
-        - oauth_signature 
-        - oauth_timestamp 
-        - oauth_nonce
-        - oauth_version
-        ... any additional parameters, as defined by the Service Provider.
-    '''
-    parameters = None # oauth parameters
-    http_method = HTTP_METHOD
-    http_url = None
-    version = VERSION
-
-    def __init__(self, http_method=HTTP_METHOD, http_url=None, parameters=None):
-        self.http_method = http_method
-        self.http_url = http_url
-        self.parameters = parameters or {}
-
-    def set_parameter(self, parameter, value):
-        self.parameters[parameter] = value
-
-    def get_parameter(self, parameter):
-        try:
-            return self.parameters[parameter]
-        except:
-            raise OAuthError('Parameter not found: %s' % parameter)
-
-    def _get_timestamp_nonce(self):
-        return self.get_parameter('oauth_timestamp'), self.get_parameter('oauth_nonce')
-
-    # get any non-oauth parameters
-    def get_nonoauth_parameters(self):
-        parameters = {}
-        for k, v in self.parameters.iteritems():
-            # ignore oauth parameters
-            if k.find('oauth_') < 0:
-                parameters[k] = v
-        return parameters
-
-    # serialize as a header for an HTTPAuth request
-    def to_header(self, realm=''):
-        auth_header = 'OAuth realm="%s"' % realm
-        # add the oauth parameters
-        if self.parameters:
-            for k, v in self.parameters.iteritems():
-                if k[:6] == 'oauth_':
-                    auth_header += ', %s="%s"' % (k, escape(str(v)))
-        return {'Authorization': auth_header}
-
-    # serialize as post data for a POST request
-    def to_postdata(self):
-        return '&'.join(['%s=%s' % (escape(str(k)), escape(str(v))) for k, v in self.parameters.iteritems()])
-
-    # serialize as a url for a GET request
-    def to_url(self):
-        return '%s?%s' % (self.get_normalized_http_url(), self.to_postdata())
-
-    # return a string that consists of all the parameters that need to be signed
-    def get_normalized_parameters(self):
-        params = self.parameters
-        try:
-            # exclude the signature if it exists
-            del params['oauth_signature']
-        except:
-            pass
-        key_values = params.items()
-        # sort lexicographically, first after key, then after value
-        key_values.sort()
-        # combine key value pairs in string and escape
-        return '&'.join(['%s=%s' % (escape(str(k)), escape(str(v))) for k, v in key_values])
-
-    # just uppercases the http method
-    def get_normalized_http_method(self):
-        return self.http_method.upper()
-
-    # parses the url and rebuilds it to be scheme://host/path
-    def get_normalized_http_url(self):
-        parts = urlparse.urlparse(self.http_url)
-        url_string = '%s://%s%s' % (parts[0], parts[1], parts[2]) # scheme, netloc, path
-        return url_string
-        
-    # set the signature parameter to the result of build_signature
-    def sign_request(self, signature_method, consumer, token):
-        # set the signature method
-        self.set_parameter('oauth_signature_method', signature_method.get_name())
-        # set the signature
-        self.set_parameter('oauth_signature', self.build_signature(signature_method, consumer, token))
-
-    def build_signature(self, signature_method, consumer, token):
-        # call the build signature method within the signature method
-        return signature_method.build_signature(self, consumer, token)
-
-    def from_request(http_method, http_url, headers=None, parameters=None, query_string=None):
-        # combine multiple parameter sources
-        if parameters is None:
-            parameters = {}
-
-        # headers
-        if headers and 'Authorization' in headers:
-            auth_header = headers['Authorization']
-            # check that the authorization header is OAuth
-            if auth_header.index('OAuth') > -1:
-                try:
-                    # get the parameters from the header
-                    header_params = OAuthRequest._split_header(auth_header)
-                    parameters.update(header_params)
-                except:
-                    raise OAuthError('Unable to parse OAuth parameters from Authorization header.')
-
-        # GET or POST query string
-        if query_string:
-            query_params = OAuthRequest._split_url_string(query_string)
-            parameters.update(query_params)
-
-        # URL parameters
-        param_str = urlparse.urlparse(http_url)[4] # query
-        url_params = OAuthRequest._split_url_string(param_str)
-        parameters.update(url_params)
-
-        if parameters:
-            return OAuthRequest(http_method, http_url, parameters)
-
-        return None
-    from_request = staticmethod(from_request)
-
-    def from_consumer_and_token(oauth_consumer, token=None, http_method=HTTP_METHOD, http_url=None, parameters=None):
-        if not parameters:
-            parameters = {}
-
-        defaults = {
-            'oauth_consumer_key': oauth_consumer.key,
-            'oauth_timestamp': generate_timestamp(),
-            'oauth_nonce': generate_nonce(),
-            'oauth_version': OAuthRequest.version,
-        }
-
-        defaults.update(parameters)
-        parameters = defaults
-
-        if token:
-            parameters['oauth_token'] = token.key
-
-        return OAuthRequest(http_method, http_url, parameters)
-    from_consumer_and_token = staticmethod(from_consumer_and_token)
-
-    def from_token_and_callback(token, callback=None, http_method=HTTP_METHOD, http_url=None, parameters=None):
-        if not parameters:
-            parameters = {}
-
-        parameters['oauth_token'] = token.key
-
-        if callback:
-            parameters['oauth_callback'] = callback
-
-        return OAuthRequest(http_method, http_url, parameters)
-    from_token_and_callback = staticmethod(from_token_and_callback)
-
-    # util function: turn Authorization: header into parameters, has to do some unescaping
-    def _split_header(header):
-        params = {}
-        parts = header.split(',')
-        for param in parts:
-            # ignore realm parameter
-            if param.find('OAuth realm') > -1:
-                continue
-            # remove whitespace
-            param = param.strip()
-            # split key-value
-            param_parts = param.split('=', 1)
-            # remove quotes and unescape the value
-            params[param_parts[0]] = urllib.unquote(param_parts[1].strip('\"'))
-        return params
-    _split_header = staticmethod(_split_header)
-    
-    # util function: turn url string into parameters, has to do some unescaping
-    def _split_url_string(param_str):
-        parameters = cgi.parse_qs(param_str, keep_blank_values=False)
-        for k, v in parameters.iteritems():
-            parameters[k] = urllib.unquote(v[0])
-        return parameters
-    _split_url_string = staticmethod(_split_url_string)
-
-# OAuthServer is a worker to check a requests validity against a data store
-class OAuthServer(object):
-    timestamp_threshold = 300 # in seconds, five minutes
-    version = VERSION
-    signature_methods = None
-    data_store = None
-
-    def __init__(self, data_store=None, signature_methods=None):
-        self.data_store = data_store
-        self.signature_methods = signature_methods or {}
-
-    def set_data_store(self, oauth_data_store):
-        self.data_store = data_store
-
-    def get_data_store(self):
-        return self.data_store
-
-    def add_signature_method(self, signature_method):
-        self.signature_methods[signature_method.get_name()] = signature_method
-        return self.signature_methods
-
-    # process a request_token request
-    # returns the request token on success
-    def fetch_request_token(self, oauth_request):
-        try:
-            # get the request token for authorization
-            token = self._get_token(oauth_request, 'request')
-        except OAuthError:
-            # no token required for the initial token request
-            version = self._get_version(oauth_request)
-            consumer = self._get_consumer(oauth_request)
-            self._check_signature(oauth_request, consumer, None)
-            # fetch a new token
-            token = self.data_store.fetch_request_token(consumer)
-        return token
-
-    # process an access_token request
-    # returns the access token on success
-    def fetch_access_token(self, oauth_request):
-        version = self._get_version(oauth_request)
-        consumer = self._get_consumer(oauth_request)
-        # get the request token
-        token = self._get_token(oauth_request, 'request')
-        self._check_signature(oauth_request, consumer, token)
-        new_token = self.data_store.fetch_access_token(consumer, token)
-        return new_token
-
-    # verify an api call, checks all the parameters
-    def verify_request(self, oauth_request):
-        # -> consumer and token
-        version = self._get_version(oauth_request)
-        consumer = self._get_consumer(oauth_request)
-        # get the access token
-        token = self._get_token(oauth_request, 'access')
-        self._check_signature(oauth_request, consumer, token)
-        parameters = oauth_request.get_nonoauth_parameters()
-        return consumer, token, parameters
-
-    # authorize a request token
-    def authorize_token(self, token, user):
-        return self.data_store.authorize_request_token(token, user)
-    
-    # get the callback url
-    def get_callback(self, oauth_request):
-        return oauth_request.get_parameter('oauth_callback')
-
-    # optional support for the authenticate header   
-    def build_authenticate_header(self, realm=''):
-        return {'WWW-Authenticate': 'OAuth realm="%s"' % realm}
-
-    # verify the correct version request for this server
-    def _get_version(self, oauth_request):
-        try:
-            version = oauth_request.get_parameter('oauth_version')
-        except:
-            version = VERSION
-        if version and version != self.version:
-            raise OAuthError('OAuth version %s not supported.' % str(version))
-        return version
-
-    # figure out the signature with some defaults
-    def _get_signature_method(self, oauth_request):
-        try:
-            signature_method = oauth_request.get_parameter('oauth_signature_method')
-        except:
-            signature_method = SIGNATURE_METHOD
-        try:
-            # get the signature method object
-            signature_method = self.signature_methods[signature_method]
-        except:
-            signature_method_names = ', '.join(self.signature_methods.keys())
-            raise OAuthError('Signature method %s not supported try one of the following: %s' % (signature_method, signature_method_names))
-
-        return signature_method
-
-    def _get_consumer(self, oauth_request):
-        consumer_key = oauth_request.get_parameter('oauth_consumer_key')
-        if not consumer_key:
-            raise OAuthError('Invalid consumer key.')
-        consumer = self.data_store.lookup_consumer(consumer_key)
-        if not consumer:
-            raise OAuthError('Invalid consumer.')
-        return consumer
-
-    # try to find the token for the provided request token key
-    def _get_token(self, oauth_request, token_type='access'):
-        token_field = oauth_request.get_parameter('oauth_token')
-        token = self.data_store.lookup_token(token_type, token_field)
-        if not token:
-            raise OAuthError('Invalid %s token: %s' % (token_type, token_field))
-        return token
-
-    def _check_signature(self, oauth_request, consumer, token):
-        timestamp, nonce = oauth_request._get_timestamp_nonce()
-        self._check_timestamp(timestamp)
-        self._check_nonce(consumer, token, nonce)
-        signature_method = self._get_signature_method(oauth_request)
-        try:
-            signature = oauth_request.get_parameter('oauth_signature')
-        except:
-            raise OAuthError('Missing signature.')
-        # validate the signature
-        valid_sig = signature_method.check_signature(oauth_request, consumer, token, signature)
-        if not valid_sig:
-            key, base = signature_method.build_signature_base_string(oauth_request, consumer, token)
-            raise OAuthError('Invalid signature. Expected signature base string: %s' % base)
-        built = signature_method.build_signature(oauth_request, consumer, token)
-
-    def _check_timestamp(self, timestamp):
-        # verify that timestamp is recentish
-        timestamp = int(timestamp)
-        now = int(time.time())
-        lapsed = now - timestamp
-        if lapsed > self.timestamp_threshold:
-            raise OAuthError('Expired timestamp: given %d and now %s has a greater difference than threshold %d' % (timestamp, now, self.timestamp_threshold))
-
-    def _check_nonce(self, consumer, token, nonce):
-        # verify that the nonce is uniqueish
-        nonce = self.data_store.lookup_nonce(consumer, token, nonce)
-        if nonce:
-            raise OAuthError('Nonce already used: %s' % str(nonce))
-
-# OAuthClient is a worker to attempt to execute a request
-class OAuthClient(object):
-    consumer = None
-    token = None
-
-    def __init__(self, oauth_consumer, oauth_token):
-        self.consumer = oauth_consumer
-        self.token = oauth_token
-
-    def get_consumer(self):
-        return self.consumer
-
-    def get_token(self):
-        return self.token
-
-    def fetch_request_token(self, oauth_request):
-        # -> OAuthToken
-        raise NotImplementedError
-
-    def fetch_access_token(self, oauth_request):
-        # -> OAuthToken
-        raise NotImplementedError
-
-    def access_resource(self, oauth_request):
-        # -> some protected resource
-        raise NotImplementedError
-
-# OAuthDataStore is a database abstraction used to lookup consumers and tokens
-class OAuthDataStore(object):
-
-    def lookup_consumer(self, key):
-        # -> OAuthConsumer
-        raise NotImplementedError
-
-    def lookup_token(self, oauth_consumer, token_type, token_token):
-        # -> OAuthToken
-        raise NotImplementedError
-
-    def lookup_nonce(self, oauth_consumer, oauth_token, nonce, timestamp):
-        # -> OAuthToken
-        raise NotImplementedError
-
-    def fetch_request_token(self, oauth_consumer):
-        # -> OAuthToken
-        raise NotImplementedError
-
-    def fetch_access_token(self, oauth_consumer, oauth_token):
-        # -> OAuthToken
-        raise NotImplementedError
-
-    def authorize_request_token(self, oauth_token, user):
-        # -> OAuthToken
-        raise NotImplementedError
-
-# OAuthSignatureMethod is a strategy class that implements a signature method
-class OAuthSignatureMethod(object):
-    def get_name(self):
-        # -> str
-        raise NotImplementedError
-
-    def build_signature_base_string(self, oauth_request, oauth_consumer, oauth_token):
-        # -> str key, str raw
-        raise NotImplementedError
-
-    def build_signature(self, oauth_request, oauth_consumer, oauth_token):
-        # -> str
-        raise NotImplementedError
-
-    def check_signature(self, oauth_request, consumer, token, signature):
-        built = self.build_signature(oauth_request, consumer, token)
-        return built == signature
-
-class OAuthSignatureMethod_HMAC_SHA1(OAuthSignatureMethod):
-
-    def get_name(self):
-        return 'HMAC-SHA1'
-        
-    def build_signature_base_string(self, oauth_request, consumer, token):
-        sig = (
-            escape(oauth_request.get_normalized_http_method()),
-            escape(oauth_request.get_normalized_http_url()),
-            escape(oauth_request.get_normalized_parameters()),
-        )
-
-        key = '%s&' % escape(consumer.secret)
-        if token:
-            key += escape(token.secret)
-        raw = '&'.join(sig)
-        return key, raw
-
-    def build_signature(self, oauth_request, consumer, token):
-        # build the base signature string
-        key, raw = self.build_signature_base_string(oauth_request, consumer, token)
-
-        # hmac object
-        try:
-            import hashlib # 2.5
-            hashed = hmac.new(key, raw, hashlib.sha1)
-        except:
-            import sha # deprecated
-            hashed = hmac.new(key, raw, sha)
-
-        # calculate the digest base 64
-        return binascii.b2a_base64(hashed.digest())[:-1]
-
-class OAuthSignatureMethod_PLAINTEXT(OAuthSignatureMethod):
-
-    def get_name(self):
-        return 'PLAINTEXT'
-
-    def build_signature_base_string(self, oauth_request, consumer, token):
-        # concatenate the consumer key and secret
-        sig = escape(consumer.secret) + '&'
-        if token:
-            sig = sig + escape(token.secret)
-        return sig
-
-    def build_signature(self, oauth_request, consumer, token):
-        return self.build_signature_base_string(oauth_request, consumer, token)

gdata/oauth/rsa.py

@@ -1,120 +0,0 @@
-#!/usr/bin/python
-
-"""
-requires tlslite - http://trevp.net/tlslite/
-
-"""
-
-import binascii
-
-from gdata.tlslite.utils import keyfactory
-from gdata.tlslite.utils import cryptomath
-
-# XXX andy: ugly local import due to module name, oauth.oauth
-import gdata.oauth as oauth
-
-class OAuthSignatureMethod_RSA_SHA1(oauth.OAuthSignatureMethod):
-  def get_name(self):
-    return "RSA-SHA1"
-
-  def _fetch_public_cert(self, oauth_request):
-    # not implemented yet, ideas are:
-    # (1) do a lookup in a table of trusted certs keyed off of consumer
-    # (2) fetch via http using a url provided by the requester
-    # (3) some sort of specific discovery code based on request
-    #
-    # either way should return a string representation of the certificate
-    raise NotImplementedError
-
-  def _fetch_private_cert(self, oauth_request):
-    # not implemented yet, ideas are:
-    # (1) do a lookup in a table of trusted certs keyed off of consumer
-    #
-    # either way should return a string representation of the certificate
-    raise NotImplementedError
-
-  def build_signature_base_string(self, oauth_request, consumer, token):
-      sig = (
-          oauth.escape(oauth_request.get_normalized_http_method()),
-          oauth.escape(oauth_request.get_normalized_http_url()),
-          oauth.escape(oauth_request.get_normalized_parameters()),
-      )
-      key = ''
-      raw = '&'.join(sig)
-      return key, raw
-
-  def build_signature(self, oauth_request, consumer, token):
-    key, base_string = self.build_signature_base_string(oauth_request,
-                                                        consumer,
-                                                        token)
-
-    # Fetch the private key cert based on the request
-    cert = self._fetch_private_cert(oauth_request)
-
-    # Pull the private key from the certificate
-    privatekey = keyfactory.parsePrivateKey(cert)
-    
-    # Convert base_string to bytes
-    #base_string_bytes = cryptomath.createByteArraySequence(base_string)
-    
-    # Sign using the key
-    signed = privatekey.hashAndSign(base_string)
-  
-    return binascii.b2a_base64(signed)[:-1]
-  
-  def check_signature(self, oauth_request, consumer, token, signature):
-    decoded_sig = base64.b64decode(signature);
-
-    key, base_string = self.build_signature_base_string(oauth_request,
-                                                        consumer,
-                                                        token)
-
-    # Fetch the public key cert based on the request
-    cert = self._fetch_public_cert(oauth_request)
-
-    # Pull the public key from the certificate
-    publickey = keyfactory.parsePEMKey(cert, public=True)
-
-    # Check the signature
-    ok = publickey.hashAndVerify(decoded_sig, base_string)
-
-    return ok
-
-
-class TestOAuthSignatureMethod_RSA_SHA1(OAuthSignatureMethod_RSA_SHA1):
-  def _fetch_public_cert(self, oauth_request):
-    cert = """
------BEGIN CERTIFICATE-----
-MIIBpjCCAQ+gAwIBAgIBATANBgkqhkiG9w0BAQUFADAZMRcwFQYDVQQDDA5UZXN0
-IFByaW5jaXBhbDAeFw03MDAxMDEwODAwMDBaFw0zODEyMzEwODAwMDBaMBkxFzAV
-BgNVBAMMDlRlc3QgUHJpbmNpcGFsMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKB
-gQC0YjCwIfYoprq/FQO6lb3asXrxLlJFuCvtinTF5p0GxvQGu5O3gYytUvtC2JlY
-zypSRjVxwxrsuRcP3e641SdASwfrmzyvIgP08N4S0IFzEURkV1wp/IpH7kH41Etb
-mUmrXSwfNZsnQRE5SYSOhh+LcK2wyQkdgcMv11l4KoBkcwIDAQABMA0GCSqGSIb3
-DQEBBQUAA4GBAGZLPEuJ5SiJ2ryq+CmEGOXfvlTtEL2nuGtr9PewxkgnOjZpUy+d
-4TvuXJbNQc8f4AMWL/tO9w0Fk80rWKp9ea8/df4qMq5qlFWlx6yOLQxumNOmECKb
-WpkUQDIDJEoFUzKMVuJf4KO/FJ345+BNLGgbJ6WujreoM1X/gYfdnJ/J
------END CERTIFICATE-----
-"""
-    return cert
-
-  def _fetch_private_cert(self, oauth_request):
-    cert = """
------BEGIN PRIVATE KEY-----
-MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBALRiMLAh9iimur8V
-A7qVvdqxevEuUkW4K+2KdMXmnQbG9Aa7k7eBjK1S+0LYmVjPKlJGNXHDGuy5Fw/d
-7rjVJ0BLB+ubPK8iA/Tw3hLQgXMRRGRXXCn8ikfuQfjUS1uZSatdLB81mydBETlJ
-hI6GH4twrbDJCR2Bwy/XWXgqgGRzAgMBAAECgYBYWVtleUzavkbrPjy0T5FMou8H
-X9u2AC2ry8vD/l7cqedtwMPp9k7TubgNFo+NGvKsl2ynyprOZR1xjQ7WgrgVB+mm
-uScOM/5HVceFuGRDhYTCObE+y1kxRloNYXnx3ei1zbeYLPCHdhxRYW7T0qcynNmw
-rn05/KO2RLjgQNalsQJBANeA3Q4Nugqy4QBUCEC09SqylT2K9FrrItqL2QKc9v0Z
-zO2uwllCbg0dwpVuYPYXYvikNHHg+aCWF+VXsb9rpPsCQQDWR9TT4ORdzoj+Nccn
-qkMsDmzt0EfNaAOwHOmVJ2RVBspPcxt5iN4HI7HNeG6U5YsFBb+/GZbgfBT3kpNG
-WPTpAkBI+gFhjfJvRw38n3g/+UeAkwMI2TJQS4n8+hid0uus3/zOjDySH3XHCUno
-cn1xOJAyZODBo47E+67R4jV1/gzbAkEAklJaspRPXP877NssM5nAZMU0/O/NGCZ+
-3jPgDUno6WbJn5cqm8MqWhW1xGkImgRk+fkDBquiq4gPiT898jusgQJAd5Zrr6Q8
-AO/0isr/3aa6O6NLQxISLKcPDk2NOccAfS/xOtfOz4sJYM3+Bs4Io9+dZGSDCA54
-Lw03eHTNQghS0A==
------END PRIVATE KEY-----
-"""
-    return cert

gdata/tlslite/BaseDB.py

@@ -1,120 +0,0 @@
-"""Base class for SharedKeyDB and VerifierDB."""
-
-import anydbm
-import thread
-
-class BaseDB:
-    def __init__(self, filename, type):
-        self.type = type
-        self.filename = filename
-        if self.filename:
-            self.db = None
-        else:
-            self.db = {}
-        self.lock = thread.allocate_lock()
-
-    def create(self):
-        """Create a new on-disk database.
-
-        @raise anydbm.error: If there's a problem creating the database.
-        """
-        if self.filename:
-            self.db = anydbm.open(self.filename, "n") #raises anydbm.error
-            self.db["--Reserved--type"] = self.type
-            self.db.sync()
-        else:
-            self.db = {}
-
-    def open(self):
-        """Open a pre-existing on-disk database.
-
-        @raise anydbm.error: If there's a problem opening the database.
-        @raise ValueError: If the database is not of the right type.
-        """
-        if not self.filename:
-            raise ValueError("Can only open on-disk databases")
-        self.db = anydbm.open(self.filename, "w") #raises anydbm.error
-        try:
-            if self.db["--Reserved--type"] != self.type:
-                raise ValueError("Not a %s database" % self.type)
-        except KeyError:
-            raise ValueError("Not a recognized database")
-
-    def __getitem__(self, username):
-        if self.db == None:
-            raise AssertionError("DB not open")
-
-        self.lock.acquire()
-        try:
-            valueStr = self.db[username]
-        finally:
-            self.lock.release()
-
-        return self._getItem(username, valueStr)
-
-    def __setitem__(self, username, value):
-        if self.db == None:
-            raise AssertionError("DB not open")
-
-        valueStr = self._setItem(username, value)
-
-        self.lock.acquire()
-        try:
-            self.db[username] = valueStr
-            if self.filename:
-                self.db.sync()
-        finally:
-            self.lock.release()
-
-    def __delitem__(self, username):
-        if self.db == None:
-            raise AssertionError("DB not open")
-
-        self.lock.acquire()
-        try:
-            del(self.db[username])
-            if self.filename:
-                self.db.sync()
-        finally:
-            self.lock.release()
-
-    def __contains__(self, username):
-        """Check if the database contains the specified username.
-
-        @type username: str
-        @param username: The username to check for.
-
-        @rtype: bool
-        @return: True if the database contains the username, False
-        otherwise.
-
-        """
-        if self.db == None:
-            raise AssertionError("DB not open")
-
-        self.lock.acquire()
-        try:
-            return self.db.has_key(username)
-        finally:
-            self.lock.release()
-
-    def check(self, username, param):
-        value = self.__getitem__(username)
-        return self._checkItem(value, username, param)
-
-    def keys(self):
-        """Return a list of usernames in the database.
-
-        @rtype: list
-        @return: The usernames in the database.
-        """
-        if self.db == None:
-            raise AssertionError("DB not open")
-
-        self.lock.acquire()
-        try:
-            usernames = self.db.keys()
-        finally:
-            self.lock.release()
-        usernames = [u for u in usernames if not u.startswith("--Reserved--")]
-        return usernames

gdata/tlslite/Checker.py

@@ -1,146 +0,0 @@
-"""Class for post-handshake certificate checking."""
-
-from utils.cryptomath import hashAndBase64
-from X509 import X509
-from X509CertChain import X509CertChain
-from errors import *
-
-
-class Checker:
-    """This class is passed to a handshake function to check the other
-    party's certificate chain.
-
-    If a handshake function completes successfully, but the Checker
-    judges the other party's certificate chain to be missing or
-    inadequate, a subclass of
-    L{tlslite.errors.TLSAuthenticationError} will be raised.
-
-    Currently, the Checker can check either an X.509 or a cryptoID
-    chain (for the latter, cryptoIDlib must be installed).
-    """
-
-    def __init__(self, cryptoID=None, protocol=None,
-                 x509Fingerprint=None,
-                 x509TrustList=None, x509CommonName=None,
-                 checkResumedSession=False):
-        """Create a new Checker instance.
-
-        You must pass in one of these argument combinations:
-         - cryptoID[, protocol] (requires cryptoIDlib)
-         - x509Fingerprint
-         - x509TrustList[, x509CommonName] (requires cryptlib_py)
-
-        @type cryptoID: str
-        @param cryptoID: A cryptoID which the other party's certificate
-        chain must match.  The cryptoIDlib module must be installed.
-        Mutually exclusive with all of the 'x509...' arguments.
-
-        @type protocol: str
-        @param protocol: A cryptoID protocol URI which the other
-        party's certificate chain must match.  Requires the 'cryptoID'
-        argument.
-
-        @type x509Fingerprint: str
-        @param x509Fingerprint: A hex-encoded X.509 end-entity
-        fingerprint which the other party's end-entity certificate must
-        match.  Mutually exclusive with the 'cryptoID' and
-        'x509TrustList' arguments.
-
-        @type x509TrustList: list of L{tlslite.X509.X509}
-        @param x509TrustList: A list of trusted root certificates.  The
-        other party must present a certificate chain which extends to
-        one of these root certificates.  The cryptlib_py module must be
-        installed.  Mutually exclusive with the 'cryptoID' and
-        'x509Fingerprint' arguments.
-
-        @type x509CommonName: str
-        @param x509CommonName: The end-entity certificate's 'CN' field
-        must match this value.  For a web server, this is typically a
-        server name such as 'www.amazon.com'.  Mutually exclusive with
-        the 'cryptoID' and 'x509Fingerprint' arguments.  Requires the
-        'x509TrustList' argument.
-
-        @type checkResumedSession: bool
-        @param checkResumedSession: If resumed sessions should be
-        checked.  This defaults to False, on the theory that if the
-        session was checked once, we don't need to bother
-        re-checking it.
-        """
-
-        if cryptoID and (x509Fingerprint or x509TrustList):
-            raise ValueError()
-        if x509Fingerprint and x509TrustList:
-            raise ValueError()
-        if x509CommonName and not x509TrustList:
-            raise ValueError()
-        if protocol and not cryptoID:
-            raise ValueError()
-        if cryptoID:
-            import cryptoIDlib #So we raise an error here
-        if x509TrustList:
-            import cryptlib_py #So we raise an error here
-        self.cryptoID = cryptoID
-        self.protocol = protocol
-        self.x509Fingerprint = x509Fingerprint
-        self.x509TrustList = x509TrustList
-        self.x509CommonName = x509CommonName
-        self.checkResumedSession = checkResumedSession
-
-    def __call__(self, connection):
-        """Check a TLSConnection.
-
-        When a Checker is passed to a handshake function, this will
-        be called at the end of the function.
-
-        @type connection: L{tlslite.TLSConnection.TLSConnection}
-        @param connection: The TLSConnection to examine.
-
-        @raise tlslite.errors.TLSAuthenticationError: If the other
-        party's certificate chain is missing or bad.
-        """
-        if not self.checkResumedSession and connection.resumed:
-            return
-
-        if self.cryptoID or self.x509Fingerprint or self.x509TrustList:
-            if connection._client:
-                chain = connection.session.serverCertChain
-            else:
-                chain = connection.session.clientCertChain
-
-            if self.x509Fingerprint or self.x509TrustList:
-                if isinstance(chain, X509CertChain):
-                    if self.x509Fingerprint:
-                        if chain.getFingerprint() != self.x509Fingerprint:
-                            raise TLSFingerprintError(\
-                                "X.509 fingerprint mismatch: %s, %s" % \
-                                (chain.getFingerprint(), self.x509Fingerprint))
-                    else: #self.x509TrustList
-                        if not chain.validate(self.x509TrustList):
-                            raise TLSValidationError("X.509 validation failure")
-                        if self.x509CommonName and \
-                               (chain.getCommonName() != self.x509CommonName):
-                           raise TLSAuthorizationError(\
-                               "X.509 Common Name mismatch: %s, %s" % \
-                               (chain.getCommonName(), self.x509CommonName))
-                elif chain:
-                    raise TLSAuthenticationTypeError()
-                else:
-                    raise TLSNoAuthenticationError()
-            elif self.cryptoID:
-                import cryptoIDlib.CertChain
-                if isinstance(chain, cryptoIDlib.CertChain.CertChain):
-                    if chain.cryptoID != self.cryptoID:
-                        raise TLSFingerprintError(\
-                            "cryptoID mismatch: %s, %s" % \
-                            (chain.cryptoID, self.cryptoID))
-                    if self.protocol:
-                        if not chain.checkProtocol(self.protocol):
-                            raise TLSAuthorizationError(\
-                            "cryptoID protocol mismatch")
-                    if not chain.validate():
-                        raise TLSValidationError("cryptoID validation failure")
-                elif chain:
-                    raise TLSAuthenticationTypeError()
-                else:
-                    raise TLSNoAuthenticationError()
-

gdata/tlslite/FileObject.py

@@ -1,220 +0,0 @@
-"""Class returned by TLSConnection.makefile()."""
-
-class FileObject:
-    """This class provides a file object interface to a
-    L{tlslite.TLSConnection.TLSConnection}.
-
-    Call makefile() on a TLSConnection to create a FileObject instance.
-
-    This class was copied, with minor modifications, from the
-    _fileobject class in socket.py.  Note that fileno() is not
-    implemented."""
-
-    default_bufsize = 16384 #TREV: changed from 8192
-
-    def __init__(self, sock, mode='rb', bufsize=-1):
-        self._sock = sock
-        self.mode = mode # Not actually used in this version
-        if bufsize < 0:
-            bufsize = self.default_bufsize
-        self.bufsize = bufsize
-        self.softspace = False
-        if bufsize == 0:
-            self._rbufsize = 1
-        elif bufsize == 1:
-            self._rbufsize = self.default_bufsize
-        else:
-            self._rbufsize = bufsize
-        self._wbufsize = bufsize
-        self._rbuf = "" # A string
-        self._wbuf = [] # A list of strings
-
-    def _getclosed(self):
-        return self._sock is not None
-    closed = property(_getclosed, doc="True if the file is closed")
-
-    def close(self):
-        try:
-            if self._sock:
-                for result in self._sock._decrefAsync(): #TREV
-                    pass
-        finally:
-            self._sock = None
-
-    def __del__(self):
-        try:
-            self.close()
-        except:
-            # close() may fail if __init__ didn't complete
-            pass
-
-    def flush(self):
-        if self._wbuf:
-            buffer = "".join(self._wbuf)
-            self._wbuf = []
-            self._sock.sendall(buffer)
-
-    #def fileno(self):
-    #    raise NotImplementedError() #TREV
-
-    def write(self, data):
-        data = str(data) # XXX Should really reject non-string non-buffers
-        if not data:
-            return
-        self._wbuf.append(data)
-        if (self._wbufsize == 0 or
-            self._wbufsize == 1 and '\n' in data or
-            self._get_wbuf_len() >= self._wbufsize):
-            self.flush()
-
-    def writelines(self, list):
-        # XXX We could do better here for very long lists
-        # XXX Should really reject non-string non-buffers
-        self._wbuf.extend(filter(None, map(str, list)))
-        if (self._wbufsize <= 1 or
-            self._get_wbuf_len() >= self._wbufsize):
-            self.flush()
-
-    def _get_wbuf_len(self):
-        buf_len = 0
-        for x in self._wbuf:
-            buf_len += len(x)
-        return buf_len
-
-    def read(self, size=-1):
-        data = self._rbuf
-        if size < 0:
-            # Read until EOF
-            buffers = []
-            if data:
-                buffers.append(data)
-            self._rbuf = ""
-            if self._rbufsize <= 1:
-                recv_size = self.default_bufsize
-            else:
-                recv_size = self._rbufsize
-            while True:
-                data = self._sock.recv(recv_size)
-                if not data:
-                    break
-                buffers.append(data)
-            return "".join(buffers)
-        else:
-            # Read until size bytes or EOF seen, whichever comes first
-            buf_len = len(data)
-            if buf_len >= size:
-                self._rbuf = data[size:]
-                return data[:size]
-            buffers = []
-            if data:
-                buffers.append(data)
-            self._rbuf = ""
-            while True:
-                left = size - buf_len
-                recv_size = max(self._rbufsize, left)
-                data = self._sock.recv(recv_size)
-                if not data:
-                    break
-                buffers.append(data)
-                n = len(data)
-                if n >= left:
-                    self._rbuf = data[left:]
-                    buffers[-1] = data[:left]
-                    break
-                buf_len += n
-            return "".join(buffers)
-
-    def readline(self, size=-1):
-        data = self._rbuf
-        if size < 0:
-            # Read until \n or EOF, whichever comes first
-            if self._rbufsize <= 1:
-                # Speed up unbuffered case
-                assert data == ""
-                buffers = []
-                recv = self._sock.recv
-                while data != "\n":
-                    data = recv(1)
-                    if not data:
-                        break
-                    buffers.append(data)
-                return "".join(buffers)
-            nl = data.find('\n')
-            if nl >= 0:
-                nl += 1
-                self._rbuf = data[nl:]
-                return data[:nl]
-            buffers = []
-            if data:
-                buffers.append(data)
-            self._rbuf = ""
-            while True:
-                data = self._sock.recv(self._rbufsize)
-                if not data:
-                    break
-                buffers.append(data)
-                nl = data.find('\n')
-                if nl >= 0:
-                    nl += 1
-                    self._rbuf = data[nl:]
-                    buffers[-1] = data[:nl]
-                    break
-            return "".join(buffers)
-        else:
-            # Read until size bytes or \n or EOF seen, whichever comes first
-            nl = data.find('\n', 0, size)
-            if nl >= 0:
-                nl += 1
-                self._rbuf = data[nl:]
-                return data[:nl]
-            buf_len = len(data)
-            if buf_len >= size:
-                self._rbuf = data[size:]
-                return data[:size]
-            buffers = []
-            if data:
-                buffers.append(data)
-            self._rbuf = ""
-            while True:
-                data = self._sock.recv(self._rbufsize)
-                if not data:
-                    break
-                buffers.append(data)
-                left = size - buf_len
-                nl = data.find('\n', 0, left)
-                if nl >= 0:
-                    nl += 1
-                    self._rbuf = data[nl:]
-                    buffers[-1] = data[:nl]
-                    break
-                n = len(data)
-                if n >= left:
-                    self._rbuf = data[left:]
-                    buffers[-1] = data[:left]
-                    break
-                buf_len += n
-            return "".join(buffers)
-
-    def readlines(self, sizehint=0):
-        total = 0
-        list = []
-        while True:
-            line = self.readline()
-            if not line:
-                break
-            list.append(line)
-            total += len(line)
-            if sizehint and total >= sizehint:
-                break
-        return list
-
-    # Iterator protocols
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        line = self.readline()
-        if not line:
-            raise StopIteration
-        return line

gdata/tlslite/HandshakeSettings.py

@@ -1,159 +0,0 @@
-"""Class for setting handshake parameters."""
-
-from constants import CertificateType
-from utils import cryptomath
-from utils import cipherfactory
-
-class HandshakeSettings:
-    """This class encapsulates various parameters that can be used with
-    a TLS handshake.
-    @sort: minKeySize, maxKeySize, cipherNames, certificateTypes,
-    minVersion, maxVersion
-
-    @type minKeySize: int
-    @ivar minKeySize: The minimum bit length for asymmetric keys.
-
-    If the other party tries to use SRP, RSA, or Diffie-Hellman
-    parameters smaller than this length, an alert will be
-    signalled.  The default is 1023.
-
-    @type maxKeySize: int
-    @ivar maxKeySize: The maximum bit length for asymmetric keys.
-
-    If the other party tries to use SRP, RSA, or Diffie-Hellman
-    parameters larger than this length, an alert will be signalled.
-    The default is 8193.
-
-    @type cipherNames: list
-    @ivar cipherNames: The allowed ciphers, in order of preference.
-
-    The allowed values in this list are 'aes256', 'aes128', '3des', and
-    'rc4'.  If these settings are used with a client handshake, they
-    determine the order of the ciphersuites offered in the ClientHello
-    message.
-
-    If these settings are used with a server handshake, the server will
-    choose whichever ciphersuite matches the earliest entry in this
-    list.
-
-    NOTE:  If '3des' is used in this list, but TLS Lite can't find an
-    add-on library that supports 3DES, then '3des' will be silently
-    removed.
-
-    The default value is ['aes256', 'aes128', '3des', 'rc4'].
-
-    @type certificateTypes: list
-    @ivar certificateTypes: The allowed certificate types, in order of
-    preference.
-
-    The allowed values in this list are 'x509' and 'cryptoID'.  This
-    list is only used with a client handshake.  The client will
-    advertise to the server which certificate types are supported, and
-    will check that the server uses one of the appropriate types.
-
-    NOTE:  If 'cryptoID' is used in this list, but cryptoIDlib is not
-    installed, then 'cryptoID' will be silently removed.
-
-    @type minVersion: tuple
-    @ivar minVersion: The minimum allowed SSL/TLS version.
-
-    This variable can be set to (3,0) for SSL 3.0, (3,1) for
-    TLS 1.0, or (3,2) for TLS 1.1.  If the other party wishes to
-    use a lower version, a protocol_version alert will be signalled.
-    The default is (3,0).
-
-    @type maxVersion: tuple
-    @ivar maxVersion: The maximum allowed SSL/TLS version.
-
-    This variable can be set to (3,0) for SSL 3.0, (3,1) for
-    TLS 1.0, or (3,2) for TLS 1.1.  If the other party wishes to
-    use a higher version, a protocol_version alert will be signalled.
-    The default is (3,2).  (WARNING: Some servers may (improperly)
-    reject clients which offer support for TLS 1.1.  In this case,
-    try lowering maxVersion to (3,1)).
-    """
-    def __init__(self):
-        self.minKeySize = 1023
-        self.maxKeySize = 8193
-        self.cipherNames = ["aes256", "aes128", "3des", "rc4"]
-        self.cipherImplementations = ["cryptlib", "openssl", "pycrypto",
-                                      "python"]
-        self.certificateTypes = ["x509", "cryptoID"]
-        self.minVersion = (3,0)
-        self.maxVersion = (3,2)
-
-    #Filters out options that are not supported
-    def _filter(self):
-        other = HandshakeSettings()
-        other.minKeySize = self.minKeySize
-        other.maxKeySize = self.maxKeySize
-        other.cipherNames = self.cipherNames
-        other.cipherImplementations = self.cipherImplementations
-        other.certificateTypes = self.certificateTypes
-        other.minVersion = self.minVersion
-        other.maxVersion = self.maxVersion
-
-        if not cipherfactory.tripleDESPresent:
-            other.cipherNames = [e for e in self.cipherNames if e != "3des"]
-        if len(other.cipherNames)==0:
-            raise ValueError("No supported ciphers")
-
-        try:
-            import cryptoIDlib
-        except ImportError:
-            other.certificateTypes = [e for e in self.certificateTypes \
-                                      if e != "cryptoID"]
-        if len(other.certificateTypes)==0:
-            raise ValueError("No supported certificate types")
-
-        if not cryptomath.cryptlibpyLoaded:
-            other.cipherImplementations = [e for e in \
-                self.cipherImplementations if e != "cryptlib"]
-        if not cryptomath.m2cryptoLoaded:
-            other.cipherImplementations = [e for e in \
-                other.cipherImplementations if e != "openssl"]
-        if not cryptomath.pycryptoLoaded:
-            other.cipherImplementations = [e for e in \
-                other.cipherImplementations if e != "pycrypto"]
-        if len(other.cipherImplementations)==0:
-            raise ValueError("No supported cipher implementations")
-
-        if other.minKeySize<512:
-            raise ValueError("minKeySize too small")
-        if other.minKeySize>16384:
-            raise ValueError("minKeySize too large")
-        if other.maxKeySize<512:
-            raise ValueError("maxKeySize too small")
-        if other.maxKeySize>16384:
-            raise ValueError("maxKeySize too large")
-        for s in other.cipherNames:
-            if s not in ("aes256", "aes128", "rc4", "3des"):
-                raise ValueError("Unknown cipher name: '%s'" % s)
-        for s in other.cipherImplementations:
-            if s not in ("cryptlib", "openssl", "python", "pycrypto"):
-                raise ValueError("Unknown cipher implementation: '%s'" % s)
-        for s in other.certificateTypes:
-            if s not in ("x509", "cryptoID"):
-                raise ValueError("Unknown certificate type: '%s'" % s)
-
-        if other.minVersion > other.maxVersion:
-            raise ValueError("Versions set incorrectly")
-
-        if not other.minVersion in ((3,0), (3,1), (3,2)):
-            raise ValueError("minVersion set incorrectly")
-
-        if not other.maxVersion in ((3,0), (3,1), (3,2)):
-            raise ValueError("maxVersion set incorrectly")
-
-        return other
-
-    def _getCertificateTypes(self):
-        l = []
-        for ct in self.certificateTypes:
-            if ct == "x509":
-                l.append(CertificateType.x509)
-            elif ct == "cryptoID":
-                l.append(CertificateType.cryptoID)
-            else:
-                raise AssertionError()
-        return l

gdata/tlslite/Session.py

@@ -1,131 +0,0 @@
-"""Class representing a TLS session."""
-
-from utils.compat import *
-from mathtls import *
-from constants import *
-
-class Session:
-    """
-    This class represents a TLS session.
-
-    TLS distinguishes between connections and sessions.  A new
-    handshake creates both a connection and a session.  Data is
-    transmitted over the connection.
-
-    The session contains a more permanent record of the handshake.  The
-    session can be inspected to determine handshake results.  The
-    session can also be used to create a new connection through
-    "session resumption". If the client and server both support this,
-    they can create a new connection based on an old session without
-    the overhead of a full handshake.
-
-    The session for a L{tlslite.TLSConnection.TLSConnection} can be
-    retrieved from the connection's 'session' attribute.
-
-    @type srpUsername: str
-    @ivar srpUsername: The client's SRP username (or None).
-
-    @type sharedKeyUsername: str
-    @ivar sharedKeyUsername: The client's shared-key username (or
-    None).
-
-    @type clientCertChain: L{tlslite.X509CertChain.X509CertChain} or
-    L{cryptoIDlib.CertChain.CertChain}
-    @ivar clientCertChain: The client's certificate chain (or None).
-
-    @type serverCertChain: L{tlslite.X509CertChain.X509CertChain} or
-    L{cryptoIDlib.CertChain.CertChain}
-    @ivar serverCertChain: The server's certificate chain (or None).
-    """
-
-    def __init__(self):
-        self.masterSecret = createByteArraySequence([])
-        self.sessionID = createByteArraySequence([])
-        self.cipherSuite = 0
-        self.srpUsername = None
-        self.sharedKeyUsername = None
-        self.clientCertChain = None
-        self.serverCertChain = None
-        self.resumable = False
-        self.sharedKey = False
-
-    def _clone(self):
-        other = Session()
-        other.masterSecret = self.masterSecret
-        other.sessionID = self.sessionID
-        other.cipherSuite = self.cipherSuite
-        other.srpUsername = self.srpUsername
-        other.sharedKeyUsername = self.sharedKeyUsername
-        other.clientCertChain = self.clientCertChain
-        other.serverCertChain = self.serverCertChain
-        other.resumable = self.resumable
-        other.sharedKey = self.sharedKey
-        return other
-
-    def _calcMasterSecret(self, version, premasterSecret, clientRandom,
-                         serverRandom):
-        if version == (3,0):
-            self.masterSecret = PRF_SSL(premasterSecret,
-                                concatArrays(clientRandom, serverRandom), 48)
-        elif version in ((3,1), (3,2)):
-            self.masterSecret = PRF(premasterSecret, "master secret",
-                                concatArrays(clientRandom, serverRandom), 48)
-        else:
-            raise AssertionError()
-
-    def valid(self):
-        """If this session can be used for session resumption.
-
-        @rtype: bool
-        @return: If this session can be used for session resumption.
-        """
-        return self.resumable or self.sharedKey
-
-    def _setResumable(self, boolean):
-        #Only let it be set if this isn't a shared key
-        if not self.sharedKey:
-            #Only let it be set to True if the sessionID is non-null
-            if (not boolean) or (boolean and self.sessionID):
-                self.resumable = boolean
-
-    def getCipherName(self):
-        """Get the name of the cipher used with this connection.
-
-        @rtype: str
-        @return: The name of the cipher used with this connection.
-        Either 'aes128', 'aes256', 'rc4', or '3des'.
-        """
-        if self.cipherSuite in CipherSuite.aes128Suites:
-            return "aes128"
-        elif self.cipherSuite in CipherSuite.aes256Suites:
-            return "aes256"
-        elif self.cipherSuite in CipherSuite.rc4Suites:
-            return "rc4"
-        elif self.cipherSuite in CipherSuite.tripleDESSuites:
-            return "3des"
-        else:
-            return None
-
-    def _createSharedKey(self, sharedKeyUsername, sharedKey):
-        if len(sharedKeyUsername)>16:
-            raise ValueError()
-        if len(sharedKey)>47:
-            raise ValueError()
-
-        self.sharedKeyUsername = sharedKeyUsername
-
-        self.sessionID = createByteArrayZeros(16)
-        for x in range(len(sharedKeyUsername)):
-            self.sessionID[x] = ord(sharedKeyUsername[x])
-
-        premasterSecret = createByteArrayZeros(48)
-        sharedKey = chr(len(sharedKey)) + sharedKey
-        for x in range(48):
-            premasterSecret[x] = ord(sharedKey[x % len(sharedKey)])
-
-        self.masterSecret = PRF(premasterSecret, "shared secret",
-                                createByteArraySequence([]), 48)
-        self.sharedKey = True
-        return self
-
-

gdata/tlslite/SessionCache.py

@@ -1,103 +0,0 @@
-"""Class for caching TLS sessions."""
-
-import thread
-import time
-
-class SessionCache:
-    """This class is used by the server to cache TLS sessions.
-
-    Caching sessions allows the client to use TLS session resumption
-    and avoid the expense of a full handshake.  To use this class,
-    simply pass a SessionCache instance into the server handshake
-    function.
-
-    This class is thread-safe.
-    """
-
-    #References to these instances
-    #are also held by the caller, who may change the 'resumable'
-    #flag, so the SessionCache must return the same instances
-    #it was passed in.
-
-    def __init__(self, maxEntries=10000, maxAge=14400):
-        """Create a new SessionCache.
-
-        @type maxEntries: int
-        @param maxEntries: The maximum size of the cache.  When this
-        limit is reached, the oldest sessions will be deleted as
-        necessary to make room for new ones.  The default is 10000.
-
-        @type maxAge: int
-        @param maxAge:  The number of seconds before a session expires
-        from the cache.  The default is 14400 (i.e. 4 hours)."""
-
-        self.lock = thread.allocate_lock()
-
-        # Maps sessionIDs to sessions
-        self.entriesDict = {}
-
-        #Circular list of (sessionID, timestamp) pairs
-        self.entriesList = [(None,None)] * maxEntries
-
-        self.firstIndex = 0
-        self.lastIndex = 0
-        self.maxAge = maxAge
-
-    def __getitem__(self, sessionID):
-        self.lock.acquire()
-        try:
-            self._purge() #Delete old items, so we're assured of a new one
-            session = self.entriesDict[sessionID]
-
-            #When we add sessions they're resumable, but it's possible
-            #for the session to be invalidated later on (if a fatal alert
-            #is returned), so we have to check for resumability before
-            #returning the session.
-
-            if session.valid():
-                return session
-            else:
-                raise KeyError()
-        finally:
-            self.lock.release()
-
-
-    def __setitem__(self, sessionID, session):
-        self.lock.acquire()
-        try:
-            #Add the new element
-            self.entriesDict[sessionID] = session
-            self.entriesList[self.lastIndex] = (sessionID, time.time())
-            self.lastIndex = (self.lastIndex+1) % len(self.entriesList)
-
-            #If the cache is full, we delete the oldest element to make an
-            #empty space
-            if self.lastIndex == self.firstIndex:
-                del(self.entriesDict[self.entriesList[self.firstIndex][0]])
-                self.firstIndex = (self.firstIndex+1) % len(self.entriesList)
-        finally:
-            self.lock.release()
-
-    #Delete expired items
-    def _purge(self):
-        currentTime = time.time()
-
-        #Search through the circular list, deleting expired elements until
-        #we reach a non-expired element.  Since elements in list are
-        #ordered in time, we can break once we reach the first non-expired
-        #element
-        index = self.firstIndex
-        while index != self.lastIndex:
-            if currentTime - self.entriesList[index][1] > self.maxAge:
-                del(self.entriesDict[self.entriesList[index][0]])
-                index = (index+1) % len(self.entriesList)
-            else:
-                break
-        self.firstIndex = index
-
-def _test():
-    import doctest, SessionCache
-    return doctest.testmod(SessionCache)
-
-if __name__ == "__main__":
-    _test()

gdata/tlslite/SharedKeyDB.py

@@ -1,58 +0,0 @@
-"""Class for storing shared keys."""
-
-from utils.cryptomath import *
-from utils.compat import *
-from mathtls import *
-from Session import Session
-from BaseDB import BaseDB
-
-class SharedKeyDB(BaseDB):
-    """This class represent an in-memory or on-disk database of shared
-    keys.
-
-    A SharedKeyDB can be passed to a server handshake function to
-    authenticate a client based on one of the shared keys.
-
-    This class is thread-safe.
-    """
-
-    def __init__(self, filename=None):
-        """Create a new SharedKeyDB.
-
-        @type filename: str
-        @param filename: Filename for an on-disk database, or None for
-        an in-memory database.  If the filename already exists, follow
-        this with a call to open().  To create a new on-disk database,
-        follow this with a call to create().
-        """
-        BaseDB.__init__(self, filename, "shared key")
-
-    def _getItem(self, username, valueStr):
-        session = Session()
-        session._createSharedKey(username, valueStr)
-        return session
-
-    def __setitem__(self, username, sharedKey):
-        """Add a shared key to the database.
-
-        @type username: str
-        @param username: The username to associate the shared key with.
-        Must be less than or equal to 16 characters in length, and must
-        not already be in the database.
-
-        @type sharedKey: str
-        @param sharedKey: The shared key to add.  Must be less than 48
-        characters in length.
-        """
-        BaseDB.__setitem__(self, username, sharedKey)
-
-    def _setItem(self, username, value):
-        if len(username)>16:
-            raise ValueError("username too long")
-        if len(value)>=48:
-            raise ValueError("shared key too long")
-        return value
-
-    def _checkItem(self, value, username, param):
-        newSession = self._getItem(username, param)
-        return value.masterSecret == newSession.masterSecret

gdata/tlslite/VerifierDB.py

@@ -1,90 +0,0 @@
-"""Class for storing SRP password verifiers."""
-
-from utils.cryptomath import *
-from utils.compat import *
-import mathtls
-from BaseDB import BaseDB
-
-class VerifierDB(BaseDB):
-    """This class represent an in-memory or on-disk database of SRP
-    password verifiers.
-
-    A VerifierDB can be passed to a server handshake to authenticate
-    a client based on one of the verifiers.
-
-    This class is thread-safe.
-    """
-    def __init__(self, filename=None):
-        """Create a new VerifierDB instance.
-
-        @type filename: str
-        @param filename: Filename for an on-disk database, or None for
-        an in-memory database.  If the filename already exists, follow
-        this with a call to open().  To create a new on-disk database,
-        follow this with a call to create().
-        """
-        BaseDB.__init__(self, filename, "verifier")
-
-    def _getItem(self, username, valueStr):
-        (N, g, salt, verifier) = valueStr.split(" ")
-        N = base64ToNumber(N)
-        g = base64ToNumber(g)
-        salt = base64ToString(salt)
-        verifier = base64ToNumber(verifier)
-        return (N, g, salt, verifier)
-
-    def __setitem__(self, username, verifierEntry):
-        """Add a verifier entry to the database.
-
-        @type username: str
-        @param username: The username to associate the verifier with.
-        Must be less than 256 characters in length.  Must not already
-        be in the database.
-
-        @type verifierEntry: tuple
-        @param verifierEntry: The verifier entry to add.  Use
-        L{tlslite.VerifierDB.VerifierDB.makeVerifier} to create a
-        verifier entry.
-        """
-        BaseDB.__setitem__(self, username, verifierEntry)
-
-
-    def _setItem(self, username, value):
-        if len(username)>=256:
-            raise ValueError("username too long")
-        N, g, salt, verifier = value
-        N = numberToBase64(N)
-        g = numberToBase64(g)
-        salt = stringToBase64(salt)
-        verifier = numberToBase64(verifier)
-        valueStr = " ".join( (N, g, salt, verifier)  )
-        return valueStr
-
-    def _checkItem(self, value, username, param):
-        (N, g, salt, verifier) = value
-        x = mathtls.makeX(salt, username, param)
-        v = powMod(g, x, N)
-        return (verifier == v)
-
-
-    def makeVerifier(username, password, bits):
-        """Create a verifier entry which can be stored in a VerifierDB.
-
-        @type username: str
-        @param username: The username for this verifier.  Must be less
-        than 256 characters in length.
-
-        @type password: str
-        @param password: The password for this verifier.
-
-        @type bits: int
-        @param bits: This values specifies which SRP group parameters
-        to use.  It must be one of (1024, 1536, 2048, 3072, 4096, 6144,
-        8192).  Larger values are more secure but slower.  2048 is a
-        good compromise between safety and speed.
-
-        @rtype: tuple
-        @return: A tuple which may be stored in a VerifierDB.
-        """
-        return mathtls.makeVerifier(username, password, bits)
-    makeVerifier = staticmethod(makeVerifier)

gdata/tlslite/X509.py

@@ -1,133 +0,0 @@
-"""Class representing an X.509 certificate."""
-
-from utils.ASN1Parser import ASN1Parser
-from utils.cryptomath import *
-from utils.keyfactory import _createPublicRSAKey
-
-
-class X509:
-    """This class represents an X.509 certificate.
-
-    @type bytes: L{array.array} of unsigned bytes
-    @ivar bytes: The DER-encoded ASN.1 certificate
-
-    @type publicKey: L{tlslite.utils.RSAKey.RSAKey}
-    @ivar publicKey: The subject public key from the certificate.
-    """
-
-    def __init__(self):
-        self.bytes = createByteArraySequence([])
-        self.publicKey = None
-
-    def parse(self, s):
-        """Parse a PEM-encoded X.509 certificate.
-
-        @type s: str
-        @param s: A PEM-encoded X.509 certificate (i.e. a base64-encoded
-        certificate wrapped with "-----BEGIN CERTIFICATE-----" and
-        "-----END CERTIFICATE-----" tags).
-        """
-
-        start = s.find("-----BEGIN CERTIFICATE-----")
-        end = s.find("-----END CERTIFICATE-----")
-        if start == -1:
-            raise SyntaxError("Missing PEM prefix")
-        if end == -1:
-            raise SyntaxError("Missing PEM postfix")
-        s = s[start+len("-----BEGIN CERTIFICATE-----") : end]
-
-        bytes = base64ToBytes(s)
-        self.parseBinary(bytes)
-        return self
-
-    def parseBinary(self, bytes):
-        """Parse a DER-encoded X.509 certificate.
-
-        @type bytes: str or L{array.array} of unsigned bytes
-        @param bytes: A DER-encoded X.509 certificate.
-        """
-
-        if isinstance(bytes, type("")):
-            bytes = stringToBytes(bytes)
-
-        self.bytes = bytes
-        p = ASN1Parser(bytes)
-
-        #Get the tbsCertificate
-        tbsCertificateP = p.getChild(0)
-
-        #Is the optional version field present?
-        #This determines which index the key is at.
-        if tbsCertificateP.value[0]==0xA0:
-            subjectPublicKeyInfoIndex = 6
-        else:
-            subjectPublicKeyInfoIndex = 5
-
-        #Get the subjectPublicKeyInfo
-        subjectPublicKeyInfoP = tbsCertificateP.getChild(\
-                                    subjectPublicKeyInfoIndex)
-
-        #Get the algorithm
-        algorithmP = subjectPublicKeyInfoP.getChild(0)
-        rsaOID = algorithmP.value
-        if list(rsaOID) != [6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 1, 5, 0]:
-            raise SyntaxError("Unrecognized AlgorithmIdentifier")
-
-        #Get the subjectPublicKey
-        subjectPublicKeyP = subjectPublicKeyInfoP.getChild(1)
-
-        #Adjust for BIT STRING encapsulation
-        if (subjectPublicKeyP.value[0] !=0):
-            raise SyntaxError()
-        subjectPublicKeyP = ASN1Parser(subjectPublicKeyP.value[1:])
-
-        #Get the modulus and exponent
-        modulusP = subjectPublicKeyP.getChild(0)
-        publicExponentP = subjectPublicKeyP.getChild(1)
-
-        #Decode them into numbers
-        n = bytesToNumber(modulusP.value)
-        e = bytesToNumber(publicExponentP.value)
-
-        #Create a public key instance
-        self.publicKey = _createPublicRSAKey(n, e)
-
-    def getFingerprint(self):
-        """Get the hex-encoded fingerprint of this certificate.
-
-        @rtype: str
-        @return: A hex-encoded fingerprint.
-        """
-        return sha.sha(self.bytes).hexdigest()
-
-    def getCommonName(self):
-        """Get the Subject's Common Name from the certificate.
-
-        The cryptlib_py module must be installed in order to use this
-        function.
-
-        @rtype: str or None
-        @return: The CN component of the certificate's subject DN, if
-        present.
-        """
-        import cryptlib_py
-        import array
-        c = cryptlib_py.cryptImportCert(self.bytes, cryptlib_py.CRYPT_UNUSED)
-        name = cryptlib_py.CRYPT_CERTINFO_COMMONNAME
-        try:
-            try:
-                length = cryptlib_py.cryptGetAttributeString(c, name, None)
-                returnVal = array.array('B', [0] * length)
-                cryptlib_py.cryptGetAttributeString(c, name, returnVal)
-                returnVal = returnVal.tostring()
-            except cryptlib_py.CryptException, e:
-                if e[0] == cryptlib_py.CRYPT_ERROR_NOTFOUND:
-                    returnVal = None
-            return returnVal
-        finally:
-            cryptlib_py.cryptDestroyCert(c)
-
-    def writeBytes(self):
-        return self.bytes
-
-

gdata/tlslite/X509CertChain.py

@@ -1,181 +0,0 @@
-"""Class representing an X.509 certificate chain."""
-
-from utils import cryptomath
-
-class X509CertChain:
-    """This class represents a chain of X.509 certificates.
-
-    @type x509List: list
-    @ivar x509List: A list of L{tlslite.X509.X509} instances,
-    starting with the end-entity certificate and with every
-    subsequent certificate certifying the previous.
-    """
-
-    def __init__(self, x509List=None):
-        """Create a new X509CertChain.
-
-        @type x509List: list
-        @param x509List: A list of L{tlslite.X509.X509} instances,
-        starting with the end-entity certificate and with every
-        subsequent certificate certifying the previous.
-        """
-        if x509List:
-            self.x509List = x509List
-        else:
-            self.x509List = []
-
-    def getNumCerts(self):
-        """Get the number of certificates in this chain.
-
-        @rtype: int
-        """
-        return len(self.x509List)
-
-    def getEndEntityPublicKey(self):
-        """Get the public key from the end-entity certificate.
-
-        @rtype: L{tlslite.utils.RSAKey.RSAKey}
-        """
-        if self.getNumCerts() == 0:
-            raise AssertionError()
-        return self.x509List[0].publicKey
-
-    def getFingerprint(self):
-        """Get the hex-encoded fingerprint of the end-entity certificate.
-
-        @rtype: str
-        @return: A hex-encoded fingerprint.
-        """
-        if self.getNumCerts() == 0:
-            raise AssertionError()
-        return self.x509List[0].getFingerprint()
-
-    def getCommonName(self):
-        """Get the Subject's Common Name from the end-entity certificate.
-
-        The cryptlib_py module must be installed in order to use this
-        function.
-
-        @rtype: str or None
-        @return: The CN component of the certificate's subject DN, if
-        present.
-        """
-        if self.getNumCerts() == 0:
-            raise AssertionError()
-        return self.x509List[0].getCommonName()
-
-    def validate(self, x509TrustList):
-        """Check the validity of the certificate chain.
-
-        This checks that every certificate in the chain validates with
-        the subsequent one, until some certificate validates with (or
-        is identical to) one of the passed-in root certificates.
-
-        The cryptlib_py module must be installed in order to use this
-        function.
-
-        @type x509TrustList: list of L{tlslite.X509.X509}
-        @param x509TrustList: A list of trusted root certificates.  The
-        certificate chain must extend to one of these certificates to
-        be considered valid.
-        """
-
-        import cryptlib_py
-        c1 = None
-        c2 = None
-        lastC = None
-        rootC = None
-
-        try:
-            rootFingerprints = [c.getFingerprint() for c in x509TrustList]
-
-            #Check that every certificate in the chain validates with the
-            #next one
-            for cert1, cert2 in zip(self.x509List, self.x509List[1:]):
-
-                #If we come upon a root certificate, we're done.
-                if cert1.getFingerprint() in rootFingerprints:
-                    return True
-
-                c1 = cryptlib_py.cryptImportCert(cert1.writeBytes(),
-                                                 cryptlib_py.CRYPT_UNUSED)
-                c2 = cryptlib_py.cryptImportCert(cert2.writeBytes(),
-                                                 cryptlib_py.CRYPT_UNUSED)
-                try:
-                    cryptlib_py.cryptCheckCert(c1, c2)
-                except:
-                    return False
-                cryptlib_py.cryptDestroyCert(c1)
-                c1 = None
-                cryptlib_py.cryptDestroyCert(c2)
-                c2 = None
-
-            #If the last certificate is one of the root certificates, we're
-            #done.
-            if self.x509List[-1].getFingerprint() in rootFingerprints:
-                return True
-
-            #Otherwise, find a root certificate that the last certificate
-            #chains to, and validate them.
-            lastC = cryptlib_py.cryptImportCert(self.x509List[-1].writeBytes(),
-                                                cryptlib_py.CRYPT_UNUSED)
-            for rootCert in x509TrustList:
-                rootC = cryptlib_py.cryptImportCert(rootCert.writeBytes(),
-                                                    cryptlib_py.CRYPT_UNUSED)
-                if self._checkChaining(lastC, rootC):
-                    try:
-                        cryptlib_py.cryptCheckCert(lastC, rootC)
-                        return True
-                    except:
-                        return False
-            return False
-        finally:
-            if not (c1 is None):
-                cryptlib_py.cryptDestroyCert(c1)
-            if not (c2 is None):
-                cryptlib_py.cryptDestroyCert(c2)
-            if not (lastC is None):
-                cryptlib_py.cryptDestroyCert(lastC)
-            if not (rootC is None):
-                cryptlib_py.cryptDestroyCert(rootC)
-
-
-
-    def _checkChaining(self, lastC, rootC):
-        import cryptlib_py
-        import array
-        def compareNames(name):
-            try:
-                length = cryptlib_py.cryptGetAttributeString(lastC, name, None)
-                lastName = array.array('B', [0] * length)
-                cryptlib_py.cryptGetAttributeString(lastC, name, lastName)
-                lastName = lastName.tostring()
-            except cryptlib_py.CryptException, e:
-                if e[0] == cryptlib_py.CRYPT_ERROR_NOTFOUND:
-                    lastName = None
-            try:
-                length = cryptlib_py.cryptGetAttributeString(rootC, name, None)
-                rootName = array.array('B', [0] * length)
-                cryptlib_py.cryptGetAttributeString(rootC, name, rootName)
-                rootName = rootName.tostring()
-            except cryptlib_py.CryptException, e:
-                if e[0] == cryptlib_py.CRYPT_ERROR_NOTFOUND:
-                    rootName = None
-
-            return lastName == rootName
-
-        cryptlib_py.cryptSetAttribute(lastC,
-                                      cryptlib_py.CRYPT_CERTINFO_ISSUERNAME,
-                                      cryptlib_py.CRYPT_UNUSED)
-
-        if not compareNames(cryptlib_py.CRYPT_CERTINFO_COUNTRYNAME):
-            return False
-        if not compareNames(cryptlib_py.CRYPT_CERTINFO_LOCALITYNAME):
-            return False
-        if not compareNames(cryptlib_py.CRYPT_CERTINFO_ORGANIZATIONNAME):
-            return False
-        if not compareNames(cryptlib_py.CRYPT_CERTINFO_ORGANIZATIONALUNITNAME):
-            return False
-        if not compareNames(cryptlib_py.CRYPT_CERTINFO_COMMONNAME):
-            return False
-        return True

gdata/tlslite/__init__.py

@@ -1,39 +0,0 @@
-"""
-TLS Lite is a free python library that implements SSL v3, TLS v1, and
-TLS v1.1.  TLS Lite supports non-traditional authentication methods
-such as SRP, shared keys, and cryptoIDs, in addition to X.509
-certificates.  TLS Lite is pure python, however it can access OpenSSL,
-cryptlib, pycrypto, and GMPY for faster crypto operations.  TLS Lite
-integrates with httplib, xmlrpclib, poplib, imaplib, smtplib,
-SocketServer, asyncore, and Twisted.
-
-To use, do::
-
-    from tlslite.api import *
-
-Then use the L{tlslite.TLSConnection.TLSConnection} class with a socket,
-or use one of the integration classes in L{tlslite.integration}.
-
-@version: 0.3.8
-"""
-__version__ = "0.3.8"
-
-__all__ = ["api",
-           "BaseDB",
-           "Checker",
-           "constants",
-           "errors",
-           "FileObject",
-           "HandshakeSettings",
-           "mathtls",
-           "messages",
-           "Session",
-           "SessionCache",
-           "SharedKeyDB",
-           "TLSConnection",
-           "TLSRecordLayer",
-           "VerifierDB",
-           "X509",
-           "X509CertChain",
-           "integration",
-           "utils"]

gdata/tlslite/api.py

@@ -1,75 +0,0 @@
-"""Import this module for easy access to TLS Lite objects.
-
-The TLS Lite API consists of classes, functions, and variables spread
-throughout this package.  Instead of importing them individually with::
-
-    from tlslite.TLSConnection import TLSConnection
-    from tlslite.HandshakeSettings import HandshakeSettings
-    from tlslite.errors import *
-    .
-    .
-
-It's easier to do::
-
-    from tlslite.api import *
-
-This imports all the important objects (TLSConnection, Checker,
-HandshakeSettings, etc.) into the global namespace.  In particular, it
-imports::
-
-    from constants import AlertLevel, AlertDescription, Fault
-    from errors import *
-    from Checker import Checker
-    from HandshakeSettings import HandshakeSettings
-    from Session import Session
-    from SessionCache import SessionCache
-    from SharedKeyDB import SharedKeyDB
-    from TLSConnection import TLSConnection
-    from VerifierDB import VerifierDB
-    from X509 import X509
-    from X509CertChain import X509CertChain
-
-    from integration.HTTPTLSConnection import HTTPTLSConnection
-    from integration.POP3_TLS import POP3_TLS
-    from integration.IMAP4_TLS import IMAP4_TLS
-    from integration.SMTP_TLS import SMTP_TLS
-    from integration.XMLRPCTransport import XMLRPCTransport
-    from integration.TLSSocketServerMixIn import TLSSocketServerMixIn
-    from integration.TLSAsyncDispatcherMixIn import TLSAsyncDispatcherMixIn
-    from integration.TLSTwistedProtocolWrapper import TLSTwistedProtocolWrapper
-    from utils.cryptomath import cryptlibpyLoaded, m2cryptoLoaded,
-                                 gmpyLoaded, pycryptoLoaded, prngName
-    from utils.keyfactory import generateRSAKey, parsePEMKey, parseXMLKey,
-                                 parseAsPublicKey, parsePrivateKey
-"""
-
-from constants import AlertLevel, AlertDescription, Fault
-from errors import *
-from Checker import Checker
-from HandshakeSettings import HandshakeSettings
-from Session import Session
-from SessionCache import SessionCache
-from SharedKeyDB import SharedKeyDB
-from TLSConnection import TLSConnection
-from VerifierDB import VerifierDB
-from X509 import X509
-from X509CertChain import X509CertChain
-
-from integration.HTTPTLSConnection import HTTPTLSConnection
-from integration.TLSSocketServerMixIn import TLSSocketServerMixIn
-from integration.TLSAsyncDispatcherMixIn import TLSAsyncDispatcherMixIn
-from integration.POP3_TLS import POP3_TLS
-from integration.IMAP4_TLS import IMAP4_TLS
-from integration.SMTP_TLS import SMTP_TLS
-from integration.XMLRPCTransport import XMLRPCTransport
-try:
-    import twisted
-    del(twisted)
-    from integration.TLSTwistedProtocolWrapper import TLSTwistedProtocolWrapper
-except ImportError:
-    pass
-
-from utils.cryptomath import cryptlibpyLoaded, m2cryptoLoaded, gmpyLoaded, \
-                             pycryptoLoaded, prngName
-from utils.keyfactory import generateRSAKey, parsePEMKey, parseXMLKey, \
-                             parseAsPublicKey, parsePrivateKey

gdata/tlslite/constants.py

@@ -1,225 +0,0 @@
-"""Constants used in various places."""
-
-class CertificateType:
-    x509 = 0
-    openpgp = 1
-    cryptoID = 2
-
-class HandshakeType:
-    hello_request = 0
-    client_hello = 1
-    server_hello = 2
-    certificate = 11
-    server_key_exchange = 12
-    certificate_request = 13
-    server_hello_done = 14
-    certificate_verify = 15
-    client_key_exchange = 16
-    finished = 20
-
-class ContentType:
-    change_cipher_spec = 20
-    alert = 21
-    handshake = 22
-    application_data = 23
-    all = (20,21,22,23)
-
-class AlertLevel:
-    warning = 1
-    fatal = 2
-
-class AlertDescription:
-    """
-    @cvar bad_record_mac: A TLS record failed to decrypt properly.
-
-    If this occurs during a shared-key or SRP handshake it most likely
-    indicates a bad password.  It may also indicate an implementation
-    error, or some tampering with the data in transit.
-
-    This alert will be signalled by the server if the SRP password is bad.  It
-    may also be signalled by the server if the SRP username is unknown to the
-    server, but it doesn't wish to reveal that fact.
-
-    This alert will be signalled by the client if the shared-key username is
-    bad.
-
-    @cvar handshake_failure: A problem occurred while handshaking.
-
-    This typically indicates a lack of common ciphersuites between client and
-    server, or some other disagreement (about SRP parameters or key sizes,
-    for example).
-
-    @cvar protocol_version: The other party's SSL/TLS version was unacceptable.
-
-    This indicates that the client and server couldn't agree on which version
-    of SSL or TLS to use.
-
-    @cvar user_canceled: The handshake is being cancelled for some reason.
-
-    """
-
-    close_notify = 0
-    unexpected_message = 10
-    bad_record_mac = 20
-    decryption_failed = 21
-    record_overflow = 22
-    decompression_failure = 30
-    handshake_failure = 40
-    no_certificate = 41 #SSLv3
-    bad_certificate = 42
-    unsupported_certificate = 43
-    certificate_revoked = 44
-    certificate_expired = 45
-    certificate_unknown = 46
-    illegal_parameter = 47
-    unknown_ca = 48
-    access_denied = 49
-    decode_error = 50
-    decrypt_error = 51
-    export_restriction = 60
-    protocol_version = 70
-    insufficient_security = 71
-    internal_error = 80
-    user_canceled = 90
-    no_renegotiation = 100
-    unknown_srp_username = 120
-    missing_srp_username = 121
-    untrusted_srp_parameters = 122
-
-class CipherSuite:
-    TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA  = 0x0050
-    TLS_SRP_SHA_WITH_AES_128_CBC_SHA = 0x0053
-    TLS_SRP_SHA_WITH_AES_256_CBC_SHA = 0x0056
-
-    TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA = 0x0051
-    TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA = 0x0054
-    TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA = 0x0057
-
-    TLS_RSA_WITH_3DES_EDE_CBC_SHA = 0x000A
-    TLS_RSA_WITH_AES_128_CBC_SHA = 0x002F
-    TLS_RSA_WITH_AES_256_CBC_SHA = 0x0035
-    TLS_RSA_WITH_RC4_128_SHA = 0x0005
-
-    srpSuites = []
-    srpSuites.append(TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA)
-    srpSuites.append(TLS_SRP_SHA_WITH_AES_128_CBC_SHA)
-    srpSuites.append(TLS_SRP_SHA_WITH_AES_256_CBC_SHA)
-    def getSrpSuites(ciphers):
-        suites = []
-        for cipher in ciphers:
-            if cipher == "aes128":
-                suites.append(CipherSuite.TLS_SRP_SHA_WITH_AES_128_CBC_SHA)
-            elif cipher == "aes256":
-                suites.append(CipherSuite.TLS_SRP_SHA_WITH_AES_256_CBC_SHA)
-            elif cipher == "3des":
-                suites.append(CipherSuite.TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA)
-        return suites
-    getSrpSuites = staticmethod(getSrpSuites)
-
-    srpRsaSuites = []
-    srpRsaSuites.append(TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA)
-    srpRsaSuites.append(TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA)
-    srpRsaSuites.append(TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA)
-    def getSrpRsaSuites(ciphers):
-        suites = []
-        for cipher in ciphers:
-            if cipher == "aes128":
-                suites.append(CipherSuite.TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA)
-            elif cipher == "aes256":
-                suites.append(CipherSuite.TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA)
-            elif cipher == "3des":
-                suites.append(CipherSuite.TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA)
-        return suites
-    getSrpRsaSuites = staticmethod(getSrpRsaSuites)
-
-    rsaSuites = []
-    rsaSuites.append(TLS_RSA_WITH_3DES_EDE_CBC_SHA)
-    rsaSuites.append(TLS_RSA_WITH_AES_128_CBC_SHA)
-    rsaSuites.append(TLS_RSA_WITH_AES_256_CBC_SHA)
-    rsaSuites.append(TLS_RSA_WITH_RC4_128_SHA)
-    def getRsaSuites(ciphers):
-        suites = []
-        for cipher in ciphers:
-            if cipher == "aes128":
-                suites.append(CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA)
-            elif cipher == "aes256":
-                suites.append(CipherSuite.TLS_RSA_WITH_AES_256_CBC_SHA)
-            elif cipher == "rc4":
-                suites.append(CipherSuite.TLS_RSA_WITH_RC4_128_SHA)
-            elif cipher == "3des":
-                suites.append(CipherSuite.TLS_RSA_WITH_3DES_EDE_CBC_SHA)
-        return suites
-    getRsaSuites = staticmethod(getRsaSuites)
-
-    tripleDESSuites = []
-    tripleDESSuites.append(TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA)
-    tripleDESSuites.append(TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA)
-    tripleDESSuites.append(TLS_RSA_WITH_3DES_EDE_CBC_SHA)
-
-    aes128Suites = []
-    aes128Suites.append(TLS_SRP_SHA_WITH_AES_128_CBC_SHA)
-    aes128Suites.append(TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA)
-    aes128Suites.append(TLS_RSA_WITH_AES_128_CBC_SHA)
-
-    aes256Suites = []
-    aes256Suites.append(TLS_SRP_SHA_WITH_AES_256_CBC_SHA)
-    aes256Suites.append(TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA)
-    aes256Suites.append(TLS_RSA_WITH_AES_256_CBC_SHA)
-
-    rc4Suites = []
-    rc4Suites.append(TLS_RSA_WITH_RC4_128_SHA)
-
-
-class Fault:
-    badUsername = 101
-    badPassword = 102
-    badA = 103
-    clientSrpFaults = range(101,104)
-
-    badVerifyMessage = 601
-    clientCertFaults = range(601,602)
-
-    badPremasterPadding = 501
-    shortPremasterSecret = 502
-    clientNoAuthFaults = range(501,503)
-
-    badIdentifier = 401
-    badSharedKey = 402
-    clientSharedKeyFaults = range(401,403)
-
-    badB = 201
-    serverFaults = range(201,202)
-
-    badFinished = 300
-    badMAC = 301
-    badPadding = 302
-    genericFaults = range(300,303)
-
-    faultAlerts = {\
-        badUsername: (AlertDescription.unknown_srp_username, \
-                      AlertDescription.bad_record_mac),\
-        badPassword: (AlertDescription.bad_record_mac,),\
-        badA: (AlertDescription.illegal_parameter,),\
-        badIdentifier: (AlertDescription.handshake_failure,),\
-        badSharedKey: (AlertDescription.bad_record_mac,),\
-        badPremasterPadding: (AlertDescription.bad_record_mac,),\
-        shortPremasterSecret: (AlertDescription.bad_record_mac,),\
-        badVerifyMessage: (AlertDescription.decrypt_error,),\
-        badFinished: (AlertDescription.decrypt_error,),\
-        badMAC: (AlertDescription.bad_record_mac,),\
-        badPadding: (AlertDescription.bad_record_mac,)
-        }
-
-    faultNames = {\
-        badUsername: "bad username",\
-        badPassword: "bad password",\
-        badA: "bad A",\
-        badIdentifier: "bad identifier",\
-        badSharedKey: "bad sharedkey",\
-        badPremasterPadding: "bad premaster padding",\
-        shortPremasterSecret: "short premaster secret",\
-        badVerifyMessage: "bad verify message",\
-        badFinished: "bad finished message",\
-        badMAC: "bad MAC",\
-        badPadding: "bad padding"
-        }

gdata/tlslite/errors.py

@@ -1,149 +0,0 @@
-"""Exception classes.
-@sort: TLSError, TLSAbruptCloseError, TLSAlert, TLSLocalAlert, TLSRemoteAlert,
-TLSAuthenticationError, TLSNoAuthenticationError, TLSAuthenticationTypeError,
-TLSFingerprintError, TLSAuthorizationError, TLSValidationError, TLSFaultError
-"""
-
-from constants import AlertDescription, AlertLevel
-
-class TLSError(Exception):
-    """Base class for all TLS Lite exceptions."""
-    pass
-
-class TLSAbruptCloseError(TLSError):
-    """The socket was closed without a proper TLS shutdown.
-
-    The TLS specification mandates that an alert of some sort
-    must be sent before the underlying socket is closed.  If the socket
-    is closed without this, it could signify that an attacker is trying
-    to truncate the connection.  It could also signify a misbehaving
-    TLS implementation, or a random network failure.
-    """
-    pass
-
-class TLSAlert(TLSError):
-    """A TLS alert has been signalled."""
-    pass
-
-    _descriptionStr = {\
-        AlertDescription.close_notify: "close_notify",\
-        AlertDescription.unexpected_message: "unexpected_message",\
-        AlertDescription.bad_record_mac: "bad_record_mac",\
-        AlertDescription.decryption_failed: "decryption_failed",\
-        AlertDescription.record_overflow: "record_overflow",\
-        AlertDescription.decompression_failure: "decompression_failure",\
-        AlertDescription.handshake_failure: "handshake_failure",\
-        AlertDescription.no_certificate: "no certificate",\
-        AlertDescription.bad_certificate: "bad_certificate",\
-        AlertDescription.unsupported_certificate: "unsupported_certificate",\
-        AlertDescription.certificate_revoked: "certificate_revoked",\
-        AlertDescription.certificate_expired: "certificate_expired",\
-        AlertDescription.certificate_unknown: "certificate_unknown",\
-        AlertDescription.illegal_parameter: "illegal_parameter",\
-        AlertDescription.unknown_ca: "unknown_ca",\
-        AlertDescription.access_denied: "access_denied",\
-        AlertDescription.decode_error: "decode_error",\
-        AlertDescription.decrypt_error: "decrypt_error",\
-        AlertDescription.export_restriction: "export_restriction",\
-        AlertDescription.protocol_version: "protocol_version",\
-        AlertDescription.insufficient_security: "insufficient_security",\
-        AlertDescription.internal_error: "internal_error",\
-        AlertDescription.user_canceled: "user_canceled",\
-        AlertDescription.no_renegotiation: "no_renegotiation",\
-        AlertDescription.unknown_srp_username: "unknown_srp_username",\
-        AlertDescription.missing_srp_username: "missing_srp_username"}
-
-class TLSLocalAlert(TLSAlert):
-    """A TLS alert has been signalled by the local implementation.
-
-    @type description: int
-    @ivar description: Set to one of the constants in
-    L{tlslite.constants.AlertDescription}
-
-    @type level: int
-    @ivar level: Set to one of the constants in
-    L{tlslite.constants.AlertLevel}
-
-    @type message: str
-    @ivar message: Description of what went wrong.
-    """
-    def __init__(self, alert, message=None):
-        self.description = alert.description
-        self.level = alert.level
-        self.message = message
-
-    def __str__(self):
-        alertStr = TLSAlert._descriptionStr.get(self.description)
-        if alertStr == None:
-            alertStr = str(self.description)
-        if self.message:
-            return alertStr + ": " + self.message
-        else:
-            return alertStr
-
-class TLSRemoteAlert(TLSAlert):
-    """A TLS alert has been signalled by the remote implementation.
-
-    @type description: int
-    @ivar description: Set to one of the constants in
-    L{tlslite.constants.AlertDescription}
-
-    @type level: int
-    @ivar level: Set to one of the constants in
-    L{tlslite.constants.AlertLevel}
-    """
-    def __init__(self, alert):
-        self.description = alert.description
-        self.level = alert.level
-
-    def __str__(self):
-        alertStr = TLSAlert._descriptionStr.get(self.description)
-        if alertStr == None:
-            alertStr = str(self.description)
-        return alertStr
-
-class TLSAuthenticationError(TLSError):
-    """The handshake succeeded, but the other party's authentication
-    was inadequate.
-
-    This exception will only be raised when a
-    L{tlslite.Checker.Checker} has been passed to a handshake function.
-    The Checker will be invoked once the handshake completes, and if
-    the Checker objects to how the other party authenticated, a
-    subclass of this exception will be raised.
-    """
-    pass
-
-class TLSNoAuthenticationError(TLSAuthenticationError):
-    """The Checker was expecting the other party to authenticate with a
-    certificate chain, but this did not occur."""
-    pass
-
-class TLSAuthenticationTypeError(TLSAuthenticationError):
-    """The Checker was expecting the other party to authenticate with a
-    different type of certificate chain."""
-    pass
-
-class TLSFingerprintError(TLSAuthenticationError):
-    """The Checker was expecting the other party to authenticate with a
-    certificate chain that matches a different fingerprint."""
-    pass
-
-class TLSAuthorizationError(TLSAuthenticationError):
-    """The Checker was expecting the other party to authenticate with a
-    certificate chain that has a different authorization."""
-    pass
-
-class TLSValidationError(TLSAuthenticationError):
-    """The Checker has determined that the other party's certificate
-    chain is invalid."""
-    pass
-
-class TLSFaultError(TLSError):
-    """The other party responded incorrectly to an induced fault.
-
-    This exception will only occur during fault testing, when a
-    TLSConnection's fault variable is set to induce some sort of
-    faulty behavior, and the other party doesn't respond appropriately.
-    """
-    pass

gdata/tlslite/integration/AsyncStateMachine.py

@@ -1,235 +0,0 @@
-"""
-A state machine for using TLS Lite with asynchronous I/O.
-"""
-
-class AsyncStateMachine:
-    """
-    This is an abstract class that's used to integrate TLS Lite with
-    asyncore and Twisted.
-
-    This class signals wantsReadsEvent() and wantsWriteEvent().  When
-    the underlying socket has become readable or writeable, the event
-    should be passed to this class by calling inReadEvent() or
-    inWriteEvent().  This class will then try to read or write through
-    the socket, and will update its state appropriately.
-
-    This class will forward higher-level events to its subclass.  For
-    example, when a complete TLS record has been received,
-    outReadEvent() will be called with the decrypted data.
-    """
-
-    def __init__(self):
-        self._clear()
-
-    def _clear(self):
-        #These store the various asynchronous operations (i.e.
-        #generators).  Only one of them, at most, is ever active at a
-        #time.
-        self.handshaker = None
-        self.closer = None
-        self.reader = None
-        self.writer = None
-
-        #This stores the result from the last call to the
-        #currently active operation.  If 0 it indicates that the
-        #operation wants to read, if 1 it indicates that the
-        #operation wants to write.  If None, there is no active
-        #operation.
-        self.result = None
-
-    def _checkAssert(self, maxActive=1):
-        #This checks that only one operation, at most, is
-        #active, and that self.result is set appropriately.
-        activeOps = 0
-        if self.handshaker:
-            activeOps += 1
-        if self.closer:
-            activeOps += 1
-        if self.reader:
-            activeOps += 1
-        if self.writer:
-            activeOps += 1
-
-        if self.result == None:
-            if activeOps != 0:
-                raise AssertionError()
-        elif self.result in (0,1):
-            if activeOps != 1:
-                raise AssertionError()
-        else:
-            raise AssertionError()
-        if activeOps > maxActive:
-            raise AssertionError()
-
-    def wantsReadEvent(self):
-        """If the state machine wants to read.
-
-        If an operation is active, this returns whether or not the
-        operation wants to read from the socket.  If an operation is
-        not active, this returns None.
-
-        @rtype: bool or None
-        @return: If the state machine wants to read.
-        """
-        if self.result != None:
-            return self.result == 0
-        return None
-
-    def wantsWriteEvent(self):
-        """If the state machine wants to write.
-
-        If an operation is active, this returns whether or not the
-        operation wants to write to the socket.  If an operation is
-        not active, this returns None.
-
-        @rtype: bool or None
-        @return: If the state machine wants to write.
-        """
-        if self.result != None:
-            return self.result == 1
-        return None
-
-    def outConnectEvent(self):
-        """Called when a handshake operation completes.
-
-        May be overridden in subclass.
-        """
-        pass
-
-    def outCloseEvent(self):
-        """Called when a close operation completes.
-
-        May be overridden in subclass.
-        """
-        pass
-
-    def outReadEvent(self, readBuffer):
-        """Called when a read operation completes.
-
-        May be overridden in subclass."""
-        pass
-
-    def outWriteEvent(self):
-        """Called when a write operation completes.
-
-        May be overridden in subclass."""
-        pass
-
-    def inReadEvent(self):
-        """Tell the state machine it can read from the socket."""
-        try:
-            self._checkAssert()
-            if self.handshaker:
-                self._doHandshakeOp()
-            elif self.closer:
-                self._doCloseOp()
-            elif self.reader:
-                self._doReadOp()
-            elif self.writer:
-                self._doWriteOp()
-            else:
-                self.reader = self.tlsConnection.readAsync(16384)
-                self._doReadOp()
-        except:
-            self._clear()
-            raise
-
-    def inWriteEvent(self):
-        """Tell the state machine it can write to the socket."""
-        try:
-            self._checkAssert()
-            if self.handshaker:
-                self._doHandshakeOp()
-            elif self.closer:
-                self._doCloseOp()
-            elif self.reader:
-                self._doReadOp()
-            elif self.writer:
-                self._doWriteOp()
-            else:
-                self.outWriteEvent()
-        except:
-            self._clear()
-            raise
-
-    def _doHandshakeOp(self):
-        try:
-            self.result = self.handshaker.next()
-        except StopIteration:
-            self.handshaker = None
-            self.result = None
-            self.outConnectEvent()
-
-    def _doCloseOp(self):
-        try:
-            self.result = self.closer.next()
-        except StopIteration:
-            self.closer = None
-            self.result = None
-            self.outCloseEvent()
-
-    def _doReadOp(self):
-        self.result = self.reader.next()
-        if not self.result in (0,1):
-            readBuffer = self.result
-            self.reader = None
-            self.result = None
-            self.outReadEvent(readBuffer)
-
-    def _doWriteOp(self):
-        try:
-            self.result = self.writer.next()
-        except StopIteration:
-            self.writer = None
-            self.result = None
-
-    def setHandshakeOp(self, handshaker):
-        """Start a handshake operation.
-
-        @type handshaker: generator
-        @param handshaker: A generator created by using one of the
-        asynchronous handshake functions (i.e. handshakeServerAsync, or
-        handshakeClientxxx(..., async=True).
-        """
-        try:
-            self._checkAssert(0)
-            self.handshaker = handshaker
-            self._doHandshakeOp()
-        except:
-            self._clear()
-            raise
-
-    def setServerHandshakeOp(self, **args):
-        """Start a handshake operation.
-
-        The arguments passed to this function will be forwarded to
-        L{tlslite.TLSConnection.TLSConnection.handshakeServerAsync}.
-        """
-        handshaker = self.tlsConnection.handshakeServerAsync(**args)
-        self.setHandshakeOp(handshaker)
-
-    def setCloseOp(self):
-        """Start a close operation.
-        """
-        try:
-            self._checkAssert(0)
-            self.closer = self.tlsConnection.closeAsync()
-            self._doCloseOp()
-        except:
-            self._clear()
-            raise
-
-    def setWriteOp(self, writeBuffer):
-        """Start a write operation.
-
-        @type writeBuffer: str
-        @param writeBuffer: The string to transmit.
-        """
-        try:
-            self._checkAssert(0)
-            self.writer = self.tlsConnection.writeAsync(writeBuffer)
-            self._doWriteOp()
-        except:
-            self._clear()
-            raise
-

gdata/tlslite/integration/ClientHelper.py

@@ -1,163 +0,0 @@
-"""
-A helper class for using TLS Lite with stdlib clients
-(httplib, xmlrpclib, imaplib, poplib).
-"""
-
-from gdata.tlslite.Checker import Checker
-
-class ClientHelper:
-    """This is a helper class used to integrate TLS Lite with various
-    TLS clients (e.g. poplib, smtplib, httplib, etc.)"""
-
-    def __init__(self,
-              username=None, password=None, sharedKey=None,
-              certChain=None, privateKey=None,
-              cryptoID=None, protocol=None,
-              x509Fingerprint=None,
-              x509TrustList=None, x509CommonName=None,
-              settings = None):
-        """
-        For client authentication, use one of these argument
-        combinations:
-         - username, password (SRP)
-         - username, sharedKey (shared-key)
-         - certChain, privateKey (certificate)
-
-        For server authentication, you can either rely on the
-        implicit mutual authentication performed by SRP or
-        shared-keys, or you can do certificate-based server
-        authentication with one of these argument combinations:
-         - cryptoID[, protocol] (requires cryptoIDlib)
-         - x509Fingerprint
-         - x509TrustList[, x509CommonName] (requires cryptlib_py)
-
-        Certificate-based server authentication is compatible with
-        SRP or certificate-based client authentication.  It is
-        not compatible with shared-keys.
-
-        The constructor does not perform the TLS handshake itself, but
-        simply stores these arguments for later.  The handshake is
-        performed only when this class needs to connect with the
-        server.  Then you should be prepared to handle TLS-specific
-        exceptions.  See the client handshake functions in
-        L{tlslite.TLSConnection.TLSConnection} for details on which
-        exceptions might be raised.
-
-        @type username: str
-        @param username: SRP or shared-key username.  Requires the
-        'password' or 'sharedKey' argument.
-
-        @type password: str
-        @param password: SRP password for mutual authentication.
-        Requires the 'username' argument.
-
-        @type sharedKey: str
-        @param sharedKey: Shared key for mutual authentication.
-        Requires the 'username' argument.
-
-        @type certChain: L{tlslite.X509CertChain.X509CertChain} or
-        L{cryptoIDlib.CertChain.CertChain}
-        @param certChain: Certificate chain for client authentication.
-        Requires the 'privateKey' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type privateKey: L{tlslite.utils.RSAKey.RSAKey}
-        @param privateKey: Private key for client authentication.
-        Requires the 'certChain' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type cryptoID: str
-        @param cryptoID: cryptoID for server authentication.  Mutually
-        exclusive with the 'x509...' arguments.
-
-        @type protocol: str
-        @param protocol: cryptoID protocol URI for server
-        authentication.  Requires the 'cryptoID' argument.
-
-        @type x509Fingerprint: str
-        @param x509Fingerprint: Hex-encoded X.509 fingerprint for
-        server authentication.  Mutually exclusive with the 'cryptoID'
-        and 'x509TrustList' arguments.
-
-        @type x509TrustList: list of L{tlslite.X509.X509}
-        @param x509TrustList: A list of trusted root certificates.  The
-        other party must present a certificate chain which extends to
-        one of these root certificates.  The cryptlib_py module must be
-        installed to use this parameter.  Mutually exclusive with the
-        'cryptoID' and 'x509Fingerprint' arguments.
-
-        @type x509CommonName: str
-        @param x509CommonName: The end-entity certificate's 'CN' field
-        must match this value.  For a web server, this is typically a
-        server name such as 'www.amazon.com'.  Mutually exclusive with
-        the 'cryptoID' and 'x509Fingerprint' arguments.  Requires the
-        'x509TrustList' argument.
-
-        @type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
-        @param settings: Various settings which can be used to control
-        the ciphersuites, certificate types, and SSL/TLS versions
-        offered by the client.
-        """
-
-        self.username = None
-        self.password = None
-        self.sharedKey = None
-        self.certChain = None
-        self.privateKey = None
-        self.checker = None
-
-        #SRP Authentication
-        if username and password and not \
-                (sharedKey or certChain or privateKey):
-            self.username = username
-            self.password = password
-
-        #Shared Key Authentication
-        elif username and sharedKey and not \
-                (password or certChain or privateKey):
-            self.username = username
-            self.sharedKey = sharedKey
-
-        #Certificate Chain Authentication
-        elif certChain and privateKey and not \
-                (username or password or sharedKey):
-            self.certChain = certChain
-            self.privateKey = privateKey
-
-        #No Authentication
-        elif not password and not username and not \
-                sharedKey and not certChain and not privateKey:
-            pass
-
-        else:
-            raise ValueError("Bad parameters")
-
-        #Authenticate the server based on its cryptoID or fingerprint
-        if sharedKey and (cryptoID or protocol or x509Fingerprint):
-            raise ValueError("Can't use shared keys with other forms of"\
-                             "authentication")
-
-        self.checker = Checker(cryptoID, protocol, x509Fingerprint,
-                               x509TrustList, x509CommonName)
-        self.settings = settings
-
-        self.tlsSession = None
-
-    def _handshake(self, tlsConnection):
-        if self.username and self.password:
-            tlsConnection.handshakeClientSRP(username=self.username,
-                                             password=self.password,
-                                             checker=self.checker,
-                                             settings=self.settings,
-                                             session=self.tlsSession)
-        elif self.username and self.sharedKey:
-            tlsConnection.handshakeClientSharedKey(username=self.username,
-                                                   sharedKey=self.sharedKey,
-                                                   settings=self.settings)
-        else:
-            tlsConnection.handshakeClientCert(certChain=self.certChain,
-                                              privateKey=self.privateKey,
-                                              checker=self.checker,
-                                              settings=self.settings,
-                                              session=self.tlsSession)
-        self.tlsSession = tlsConnection.session

gdata/tlslite/integration/HTTPTLSConnection.py

@@ -1,169 +0,0 @@
-"""TLS Lite + httplib."""
-
-import socket
-import httplib
-from gdata.tlslite.TLSConnection import TLSConnection
-from gdata.tlslite.integration.ClientHelper import ClientHelper
-
-
-class HTTPBaseTLSConnection(httplib.HTTPConnection):
-    """This abstract class provides a framework for adding TLS support
-    to httplib."""
-
-    default_port = 443
-
-    def __init__(self, host, port=None, strict=None):
-        if strict == None:
-            #Python 2.2 doesn't support strict
-            httplib.HTTPConnection.__init__(self, host, port)
-        else:
-            httplib.HTTPConnection.__init__(self, host, port, strict)
-
-    def connect(self):
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        if hasattr(sock, 'settimeout'):
-            sock.settimeout(10)
-        sock.connect((self.host, self.port))
-
-        #Use a TLSConnection to emulate a socket
-        self.sock = TLSConnection(sock)
-
-        #When httplib closes this, close the socket
-        self.sock.closeSocket = True
-        self._handshake(self.sock)
-
-    def _handshake(self, tlsConnection):
-        """Called to perform some sort of handshake.
-
-        This method must be overridden in a subclass to do some type of
-        handshake.  This method will be called after the socket has
-        been connected but before any data has been sent.  If this
-        method does not raise an exception, the TLS connection will be
-        considered valid.
-
-        This method may (or may not) be called every time an HTTP
-        request is performed, depending on whether the underlying HTTP
-        connection is persistent.
-
-        @type tlsConnection: L{tlslite.TLSConnection.TLSConnection}
-        @param tlsConnection: The connection to perform the handshake
-        on.
-        """
-        raise NotImplementedError()
-
-
-class HTTPTLSConnection(HTTPBaseTLSConnection, ClientHelper):
-    """This class extends L{HTTPBaseTLSConnection} to support the
-    common types of handshaking."""
-
-    def __init__(self, host, port=None,
-                 username=None, password=None, sharedKey=None,
-                 certChain=None, privateKey=None,
-                 cryptoID=None, protocol=None,
-                 x509Fingerprint=None,
-                 x509TrustList=None, x509CommonName=None,
-                 settings = None):
-        """Create a new HTTPTLSConnection.
-
-        For client authentication, use one of these argument
-        combinations:
-         - username, password (SRP)
-         - username, sharedKey (shared-key)
-         - certChain, privateKey (certificate)
-
-        For server authentication, you can either rely on the
-        implicit mutual authentication performed by SRP or
-        shared-keys, or you can do certificate-based server
-        authentication with one of these argument combinations:
-         - cryptoID[, protocol] (requires cryptoIDlib)
-         - x509Fingerprint
-         - x509TrustList[, x509CommonName] (requires cryptlib_py)
-
-        Certificate-based server authentication is compatible with
-        SRP or certificate-based client authentication.  It is
-        not compatible with shared-keys.
-
-        The constructor does not perform the TLS handshake itself, but
-        simply stores these arguments for later.  The handshake is
-        performed only when this class needs to connect with the
-        server.  Thus you should be prepared to handle TLS-specific
-        exceptions when calling methods inherited from
-        L{httplib.HTTPConnection} such as request(), connect(), and
-        send().  See the client handshake functions in
-        L{tlslite.TLSConnection.TLSConnection} for details on which
-        exceptions might be raised.
-
-        @type host: str
-        @param host: Server to connect to.
-
-        @type port: int
-        @param port: Port to connect to.
-
-        @type username: str
-        @param username: SRP or shared-key username.  Requires the
-        'password' or 'sharedKey' argument.
-
-        @type password: str
-        @param password: SRP password for mutual authentication.
-        Requires the 'username' argument.
-
-        @type sharedKey: str
-        @param sharedKey: Shared key for mutual authentication.
-        Requires the 'username' argument.
-
-        @type certChain: L{tlslite.X509CertChain.X509CertChain} or
-        L{cryptoIDlib.CertChain.CertChain}
-        @param certChain: Certificate chain for client authentication.
-        Requires the 'privateKey' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type privateKey: L{tlslite.utils.RSAKey.RSAKey}
-        @param privateKey: Private key for client authentication.
-        Requires the 'certChain' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type cryptoID: str
-        @param cryptoID: cryptoID for server authentication.  Mutually
-        exclusive with the 'x509...' arguments.
-
-        @type protocol: str
-        @param protocol: cryptoID protocol URI for server
-        authentication.  Requires the 'cryptoID' argument.
-
-        @type x509Fingerprint: str
-        @param x509Fingerprint: Hex-encoded X.509 fingerprint for
-        server authentication.  Mutually exclusive with the 'cryptoID'
-        and 'x509TrustList' arguments.
-
-        @type x509TrustList: list of L{tlslite.X509.X509}
-        @param x509TrustList: A list of trusted root certificates.  The
-        other party must present a certificate chain which extends to
-        one of these root certificates.  The cryptlib_py module must be
-        installed to use this parameter.  Mutually exclusive with the
-        'cryptoID' and 'x509Fingerprint' arguments.
-
-        @type x509CommonName: str
-        @param x509CommonName: The end-entity certificate's 'CN' field
-        must match this value.  For a web server, this is typically a
-        server name such as 'www.amazon.com'.  Mutually exclusive with
-        the 'cryptoID' and 'x509Fingerprint' arguments.  Requires the
-        'x509TrustList' argument.
-
-        @type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
-        @param settings: Various settings which can be used to control
-        the ciphersuites, certificate types, and SSL/TLS versions
-        offered by the client.
-        """
-
-        HTTPBaseTLSConnection.__init__(self, host, port)
-
-        ClientHelper.__init__(self,
-                 username, password, sharedKey,
-                 certChain, privateKey,
-                 cryptoID, protocol,
-                 x509Fingerprint,
-                 x509TrustList, x509CommonName,
-                 settings)
-
-    def _handshake(self, tlsConnection):
-        ClientHelper._handshake(self, tlsConnection)

gdata/tlslite/integration/IMAP4_TLS.py

@@ -1,132 +0,0 @@
-"""TLS Lite + imaplib."""
-
-import socket
-from imaplib import IMAP4
-from gdata.tlslite.TLSConnection import TLSConnection
-from gdata.tlslite.integration.ClientHelper import ClientHelper
-
-# IMAP TLS PORT
-IMAP4_TLS_PORT = 993
-
-class IMAP4_TLS(IMAP4, ClientHelper):
-    """This class extends L{imaplib.IMAP4} with TLS support."""
-
-    def __init__(self, host = '', port = IMAP4_TLS_PORT,
-                 username=None, password=None, sharedKey=None,
-                 certChain=None, privateKey=None,
-                 cryptoID=None, protocol=None,
-                 x509Fingerprint=None,
-                 x509TrustList=None, x509CommonName=None,
-                 settings=None):
-        """Create a new IMAP4_TLS.
-
-        For client authentication, use one of these argument
-        combinations:
-         - username, password (SRP)
-         - username, sharedKey (shared-key)
-         - certChain, privateKey (certificate)
-
-        For server authentication, you can either rely on the
-        implicit mutual authentication performed by SRP or
-        shared-keys, or you can do certificate-based server
-        authentication with one of these argument combinations:
-         - cryptoID[, protocol] (requires cryptoIDlib)
-         - x509Fingerprint
-         - x509TrustList[, x509CommonName] (requires cryptlib_py)
-
-        Certificate-based server authentication is compatible with
-        SRP or certificate-based client authentication.  It is
-        not compatible with shared-keys.
-
-        The caller should be prepared to handle TLS-specific
-        exceptions.  See the client handshake functions in
-        L{tlslite.TLSConnection.TLSConnection} for details on which
-        exceptions might be raised.
-
-        @type host: str
-        @param host: Server to connect to.
-
-        @type port: int
-        @param port: Port to connect to.
-
-        @type username: str
-        @param username: SRP or shared-key username.  Requires the
-        'password' or 'sharedKey' argument.
-
-        @type password: str
-        @param password: SRP password for mutual authentication.
-        Requires the 'username' argument.
-
-        @type sharedKey: str
-        @param sharedKey: Shared key for mutual authentication.
-        Requires the 'username' argument.
-
-        @type certChain: L{tlslite.X509CertChain.X509CertChain} or
-        L{cryptoIDlib.CertChain.CertChain}
-        @param certChain: Certificate chain for client authentication.
-        Requires the 'privateKey' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type privateKey: L{tlslite.utils.RSAKey.RSAKey}
-        @param privateKey: Private key for client authentication.
-        Requires the 'certChain' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type cryptoID: str
-        @param cryptoID: cryptoID for server authentication.  Mutually
-        exclusive with the 'x509...' arguments.
-
-        @type protocol: str
-        @param protocol: cryptoID protocol URI for server
-        authentication.  Requires the 'cryptoID' argument.
-
-        @type x509Fingerprint: str
-        @param x509Fingerprint: Hex-encoded X.509 fingerprint for
-        server authentication.  Mutually exclusive with the 'cryptoID'
-        and 'x509TrustList' arguments.
-
-        @type x509TrustList: list of L{tlslite.X509.X509}
-        @param x509TrustList: A list of trusted root certificates.  The
-        other party must present a certificate chain which extends to
-        one of these root certificates.  The cryptlib_py module must be
-        installed to use this parameter.  Mutually exclusive with the
-        'cryptoID' and 'x509Fingerprint' arguments.
-
-        @type x509CommonName: str
-        @param x509CommonName: The end-entity certificate's 'CN' field
-        must match this value.  For a web server, this is typically a
-        server name such as 'www.amazon.com'.  Mutually exclusive with
-        the 'cryptoID' and 'x509Fingerprint' arguments.  Requires the
-        'x509TrustList' argument.
-
-        @type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
-        @param settings: Various settings which can be used to control
-        the ciphersuites, certificate types, and SSL/TLS versions
-        offered by the client.
-        """
-
-        ClientHelper.__init__(self,
-                 username, password, sharedKey,
-                 certChain, privateKey,
-                 cryptoID, protocol,
-                 x509Fingerprint,
-                 x509TrustList, x509CommonName,
-                 settings)
-
-        IMAP4.__init__(self, host, port)
-
-
-    def open(self, host = '', port = IMAP4_TLS_PORT):
-        """Setup connection to remote server on "host:port".
-
-        This connection will be used by the routines:
-        read, readline, send, shutdown.
-        """
-        self.host = host
-        self.port = port
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.sock.connect((host, port))
-        self.sock = TLSConnection(self.sock)
-        self.sock.closeSocket = True
-        ClientHelper._handshake(self, self.sock)
-        self.file = self.sock.makefile('rb')

gdata/tlslite/integration/IntegrationHelper.py

@@ -1,52 +0,0 @@
-
-class IntegrationHelper:
-
-    def __init__(self,
-              username=None, password=None, sharedKey=None,
-              certChain=None, privateKey=None,
-              cryptoID=None, protocol=None,
-              x509Fingerprint=None,
-              x509TrustList=None, x509CommonName=None,
-              settings = None):
-
-        self.username = None
-        self.password = None
-        self.sharedKey = None
-        self.certChain = None
-        self.privateKey = None
-        self.checker = None
-
-        #SRP Authentication
-        if username and password and not \
-                (sharedKey or certChain or privateKey):
-            self.username = username
-            self.password = password
-
-        #Shared Key Authentication
-        elif username and sharedKey and not \
-                (password or certChain or privateKey):
-            self.username = username
-            self.sharedKey = sharedKey
-
-        #Certificate Chain Authentication
-        elif certChain and privateKey and not \
-                (username or password or sharedKey):
-            self.certChain = certChain
-            self.privateKey = privateKey
-
-        #No Authentication
-        elif not password and not username and not \
-                sharedKey and not certChain and not privateKey:
-            pass
-
-        else:
-            raise ValueError("Bad parameters")
-
-        #Authenticate the server based on its cryptoID or fingerprint
-        if sharedKey and (cryptoID or protocol or x509Fingerprint):
-            raise ValueError("Can't use shared keys with other forms of"\
-                             "authentication")
-
-        self.checker = Checker(cryptoID, protocol, x509Fingerprint,
-                               x509TrustList, x509CommonName)
-        self.settings = settings

gdata/tlslite/integration/POP3_TLS.py

@@ -1,142 +0,0 @@
-"""TLS Lite + poplib."""
-
-import socket
-from poplib import POP3
-from gdata.tlslite.TLSConnection import TLSConnection
-from gdata.tlslite.integration.ClientHelper import ClientHelper
-
-# POP TLS PORT
-POP3_TLS_PORT = 995
-
-class POP3_TLS(POP3, ClientHelper):
-    """This class extends L{poplib.POP3} with TLS support."""
-
-    def __init__(self, host, port = POP3_TLS_PORT,
-                 username=None, password=None, sharedKey=None,
-                 certChain=None, privateKey=None,
-                 cryptoID=None, protocol=None,
-                 x509Fingerprint=None,
-                 x509TrustList=None, x509CommonName=None,
-                 settings=None):
-        """Create a new POP3_TLS.
-
-        For client authentication, use one of these argument
-        combinations:
-         - username, password (SRP)
-         - username, sharedKey (shared-key)
-         - certChain, privateKey (certificate)
-
-        For server authentication, you can either rely on the
-        implicit mutual authentication performed by SRP or
-        shared-keys, or you can do certificate-based server
-        authentication with one of these argument combinations:
-         - cryptoID[, protocol] (requires cryptoIDlib)
-         - x509Fingerprint
-         - x509TrustList[, x509CommonName] (requires cryptlib_py)
-
-        Certificate-based server authentication is compatible with
-        SRP or certificate-based client authentication.  It is
-        not compatible with shared-keys.
-
-        The caller should be prepared to handle TLS-specific
-        exceptions.  See the client handshake functions in
-        L{tlslite.TLSConnection.TLSConnection} for details on which
-        exceptions might be raised.
-
-        @type host: str
-        @param host: Server to connect to.
-
-        @type port: int
-        @param port: Port to connect to.
-
-        @type username: str
-        @param username: SRP or shared-key username.  Requires the
-        'password' or 'sharedKey' argument.
-
-        @type password: str
-        @param password: SRP password for mutual authentication.
-        Requires the 'username' argument.
-
-        @type sharedKey: str
-        @param sharedKey: Shared key for mutual authentication.
-        Requires the 'username' argument.
-
-        @type certChain: L{tlslite.X509CertChain.X509CertChain} or
-        L{cryptoIDlib.CertChain.CertChain}
-        @param certChain: Certificate chain for client authentication.
-        Requires the 'privateKey' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type privateKey: L{tlslite.utils.RSAKey.RSAKey}
-        @param privateKey: Private key for client authentication.
-        Requires the 'certChain' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type cryptoID: str
-        @param cryptoID: cryptoID for server authentication.  Mutually
-        exclusive with the 'x509...' arguments.
-
-        @type protocol: str
-        @param protocol: cryptoID protocol URI for server
-        authentication.  Requires the 'cryptoID' argument.
-
-        @type x509Fingerprint: str
-        @param x509Fingerprint: Hex-encoded X.509 fingerprint for
-        server authentication.  Mutually exclusive with the 'cryptoID'
-        and 'x509TrustList' arguments.
-
-        @type x509TrustList: list of L{tlslite.X509.X509}
-        @param x509TrustList: A list of trusted root certificates.  The
-        other party must present a certificate chain which extends to
-        one of these root certificates.  The cryptlib_py module must be
-        installed to use this parameter.  Mutually exclusive with the
-        'cryptoID' and 'x509Fingerprint' arguments.
-
-        @type x509CommonName: str
-        @param x509CommonName: The end-entity certificate's 'CN' field
-        must match this value.  For a web server, this is typically a
-        server name such as 'www.amazon.com'.  Mutually exclusive with
-        the 'cryptoID' and 'x509Fingerprint' arguments.  Requires the
-        'x509TrustList' argument.
-
-        @type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
-        @param settings: Various settings which can be used to control
-        the ciphersuites, certificate types, and SSL/TLS versions
-        offered by the client.
-        """
-
-        self.host = host
-        self.port = port
-        msg = "getaddrinfo returns an empty list"
-        self.sock = None
-        for res in socket.getaddrinfo(self.host, self.port, 0, socket.SOCK_STREAM):
-            af, socktype, proto, canonname, sa = res
-            try:
-                self.sock = socket.socket(af, socktype, proto)
-                self.sock.connect(sa)
-            except socket.error, msg:
-                if self.sock:
-                    self.sock.close()
-                self.sock = None
-                continue
-            break
-        if not self.sock:
-            raise socket.error, msg
-
-        ### New code below (all else copied from poplib)
-        ClientHelper.__init__(self,
-                 username, password, sharedKey,
-                 certChain, privateKey,
-                 cryptoID, protocol,
-                 x509Fingerprint,
-                 x509TrustList, x509CommonName,
-                 settings)
-
-        self.sock = TLSConnection(self.sock)
-        self.sock.closeSocket = True
-        ClientHelper._handshake(self, self.sock)
-        ###
-
-        self.file = self.sock.makefile('rb')
-        self._debugging = 0
-        self.welcome = self._getresp()

gdata/tlslite/integration/SMTP_TLS.py

@@ -1,114 +0,0 @@
-"""TLS Lite + smtplib."""
-
-from smtplib import SMTP
-from gdata.tlslite.TLSConnection import TLSConnection
-from gdata.tlslite.integration.ClientHelper import ClientHelper
-
-class SMTP_TLS(SMTP):
-    """This class extends L{smtplib.SMTP} with TLS support."""
-
-    def starttls(self,
-                 username=None, password=None, sharedKey=None,
-                 certChain=None, privateKey=None,
-                 cryptoID=None, protocol=None,
-                 x509Fingerprint=None,
-                 x509TrustList=None, x509CommonName=None,
-                 settings=None):
-        """Puts the connection to the SMTP server into TLS mode.
-
-        If the server supports TLS, this will encrypt the rest of the SMTP
-        session.
-
-        For client authentication, use one of these argument
-        combinations:
-         - username, password (SRP)
-         - username, sharedKey (shared-key)
-         - certChain, privateKey (certificate)
-
-        For server authentication, you can either rely on the
-        implicit mutual authentication performed by SRP or
-        shared-keys, or you can do certificate-based server
-        authentication with one of these argument combinations:
-         - cryptoID[, protocol] (requires cryptoIDlib)
-         - x509Fingerprint
-         - x509TrustList[, x509CommonName] (requires cryptlib_py)
-
-        Certificate-based server authentication is compatible with
-        SRP or certificate-based client authentication.  It is
-        not compatible with shared-keys.
-
-        The caller should be prepared to handle TLS-specific
-        exceptions.  See the client handshake functions in
-        L{tlslite.TLSConnection.TLSConnection} for details on which
-        exceptions might be raised.
-
-        @type username: str
-        @param username: SRP or shared-key username.  Requires the
-        'password' or 'sharedKey' argument.
-
-        @type password: str
-        @param password: SRP password for mutual authentication.
-        Requires the 'username' argument.
-
-        @type sharedKey: str
-        @param sharedKey: Shared key for mutual authentication.
-        Requires the 'username' argument.
-
-        @type certChain: L{tlslite.X509CertChain.X509CertChain} or
-        L{cryptoIDlib.CertChain.CertChain}
-        @param certChain: Certificate chain for client authentication.
-        Requires the 'privateKey' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type privateKey: L{tlslite.utils.RSAKey.RSAKey}
-        @param privateKey: Private key for client authentication.
-        Requires the 'certChain' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type cryptoID: str
-        @param cryptoID: cryptoID for server authentication.  Mutually
-        exclusive with the 'x509...' arguments.
-
-        @type protocol: str
-        @param protocol: cryptoID protocol URI for server
-        authentication.  Requires the 'cryptoID' argument.
-
-        @type x509Fingerprint: str
-        @param x509Fingerprint: Hex-encoded X.509 fingerprint for
-        server authentication.  Mutually exclusive with the 'cryptoID'
-        and 'x509TrustList' arguments.
-
-        @type x509TrustList: list of L{tlslite.X509.X509}
-        @param x509TrustList: A list of trusted root certificates.  The
-        other party must present a certificate chain which extends to
-        one of these root certificates.  The cryptlib_py module must be
-        installed to use this parameter.  Mutually exclusive with the
-        'cryptoID' and 'x509Fingerprint' arguments.
-
-        @type x509CommonName: str
-        @param x509CommonName: The end-entity certificate's 'CN' field
-        must match this value.  For a web server, this is typically a
-        server name such as 'www.amazon.com'.  Mutually exclusive with
-        the 'cryptoID' and 'x509Fingerprint' arguments.  Requires the
-        'x509TrustList' argument.
-
-        @type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
-        @param settings: Various settings which can be used to control
-        the ciphersuites, certificate types, and SSL/TLS versions
-        offered by the client.
-        """
-        (resp, reply) = self.docmd("STARTTLS")
-        if resp == 220:
-            helper = ClientHelper(
-                     username, password, sharedKey,
-                     certChain, privateKey,
-                     cryptoID, protocol,
-                     x509Fingerprint,
-                     x509TrustList, x509CommonName,
-                     settings)
-            conn = TLSConnection(self.sock)
-            conn.closeSocket = True
-            helper._handshake(conn)
-            self.sock = conn
-            self.file = conn.makefile('rb')
-        return (resp, reply)

gdata/tlslite/integration/TLSAsyncDispatcherMixIn.py

@@ -1,139 +0,0 @@
-"""TLS Lite + asyncore."""
-
-
-import asyncore
-from gdata.tlslite.TLSConnection import TLSConnection
-from AsyncStateMachine import AsyncStateMachine
-
-
-class TLSAsyncDispatcherMixIn(AsyncStateMachine):
-    """This class can be "mixed in" with an
-    L{asyncore.dispatcher} to add TLS support.
-
-    This class essentially sits between the dispatcher and the select
-    loop, intercepting events and only calling the dispatcher when
-    applicable.
-
-    In the case of handle_read(), a read operation will be activated,
-    and when it completes, the bytes will be placed in a buffer where
-    the dispatcher can retrieve them by calling recv(), and the
-    dispatcher's handle_read() will be called.
-
-    In the case of handle_write(), the dispatcher's handle_write() will
-    be called, and when it calls send(), a write operation will be
-    activated.
-
-    To use this class, you must combine it with an asyncore.dispatcher,
-    and pass in a handshake operation with setServerHandshakeOp().
-
-    Below is an example of using this class with medusa.  This class is
-    mixed in with http_channel to create http_tls_channel.  Note:
-     1. the mix-in is listed first in the inheritance list
-
-     2. the input buffer size must be at least 16K, otherwise the
-       dispatcher might not read all the bytes from the TLS layer,
-       leaving some bytes in limbo.
-
-     3. IE seems to have a problem receiving a whole HTTP response in a
-     single TLS record, so HTML pages containing '\\r\\n\\r\\n' won't
-     be displayed on IE.
-
-    Add the following text into 'start_medusa.py', in the 'HTTP Server'
-    section::
-
-        from tlslite.api import *
-        s = open("./serverX509Cert.pem").read()
-        x509 = X509()
-        x509.parse(s)
-        certChain = X509CertChain([x509])
-
-        s = open("./serverX509Key.pem").read()
-        privateKey = parsePEMKey(s, private=True)
-
-        class http_tls_channel(TLSAsyncDispatcherMixIn,
-                               http_server.http_channel):
-            ac_in_buffer_size = 16384
-
-            def __init__ (self, server, conn, addr):
-                http_server.http_channel.__init__(self, server, conn, addr)
-                TLSAsyncDispatcherMixIn.__init__(self, conn)
-                self.tlsConnection.ignoreAbruptClose = True
-                self.setServerHandshakeOp(certChain=certChain,
-                                          privateKey=privateKey)
-
-        hs.channel_class = http_tls_channel
-
-    If the TLS layer raises an exception, the exception will be caught
-    in asyncore.dispatcher, which will call close() on this class.  The
-    TLS layer always closes the TLS connection before raising an
-    exception, so the close operation will complete right away, causing
-    asyncore.dispatcher.close() to be called, which closes the socket
-    and removes this instance from the asyncore loop.
-
-    """
-
-
-    def __init__(self, sock=None):
-        AsyncStateMachine.__init__(self)
-
-        if sock:
-            self.tlsConnection = TLSConnection(sock)
-
-        #Calculate the sibling I'm being mixed in with.
-        #This is necessary since we override functions
-        #like readable(), handle_read(), etc., but we
-        #also want to call the sibling's versions.
-        for cl in self.__class__.__bases__:
-            if cl != TLSAsyncDispatcherMixIn and cl != AsyncStateMachine:
-                self.siblingClass = cl
-                break
-        else:
-            raise AssertionError()
-
-    def readable(self):
-        result = self.wantsReadEvent()
-        if result != None:
-            return result
-        return self.siblingClass.readable(self)
-
-    def writable(self):
-        result = self.wantsWriteEvent()
-        if result != None:
-            return result
-        return self.siblingClass.writable(self)
-
-    def handle_read(self):
-        self.inReadEvent()
-
-    def handle_write(self):
-        self.inWriteEvent()
-
-    def outConnectEvent(self):
-        self.siblingClass.handle_connect(self)
-
-    def outCloseEvent(self):
-        asyncore.dispatcher.close(self)
-
-    def outReadEvent(self, readBuffer):
-        self.readBuffer = readBuffer
-        self.siblingClass.handle_read(self)
-
-    def outWriteEvent(self):
-        self.siblingClass.handle_write(self)
-
-    def recv(self, bufferSize=16384):
-        if bufferSize < 16384 or self.readBuffer == None:
-            raise AssertionError()
-        returnValue = self.readBuffer
-        self.readBuffer = None
-        return returnValue
-
-    def send(self, writeBuffer):
-        self.setWriteOp(writeBuffer)
-        return len(writeBuffer)
-
-    def close(self):
-        if hasattr(self, "tlsConnection"):
-            self.setCloseOp()
-        else:
-            asyncore.dispatcher.close(self)

gdata/tlslite/integration/TLSSocketServerMixIn.py

@@ -1,59 +0,0 @@
-"""TLS Lite + SocketServer."""
-
-from gdata.tlslite.TLSConnection import TLSConnection
-
-class TLSSocketServerMixIn:
-    """
-    This class can be mixed in with any L{SocketServer.TCPServer} to
-    add TLS support.
-
-    To use this class, define a new class that inherits from it and
-    some L{SocketServer.TCPServer} (with the mix-in first). Then
-    implement the handshake() method, doing some sort of server
-    handshake on the connection argument.  If the handshake method
-    returns True, the RequestHandler will be triggered.  Below is a
-    complete example of a threaded HTTPS server::
-
-        from SocketServer import *
-        from BaseHTTPServer import *
-        from SimpleHTTPServer import *
-        from tlslite.api import *
-
-        s = open("./serverX509Cert.pem").read()
-        x509 = X509()
-        x509.parse(s)
-        certChain = X509CertChain([x509])
-
-        s = open("./serverX509Key.pem").read()
-        privateKey = parsePEMKey(s, private=True)
-
-        sessionCache = SessionCache()
-
-        class MyHTTPServer(ThreadingMixIn, TLSSocketServerMixIn,
-                           HTTPServer):
-          def handshake(self, tlsConnection):
-              try:
-                  tlsConnection.handshakeServer(certChain=certChain,
-                                                privateKey=privateKey,
-                                                sessionCache=sessionCache)
-                  tlsConnection.ignoreAbruptClose = True
-                  return True
-              except TLSError, error:
-                  print "Handshake failure:", str(error)
-                  return False
-
-        httpd = MyHTTPServer(('localhost', 443), SimpleHTTPRequestHandler)
-        httpd.serve_forever()
-    """
-
-
-    def finish_request(self, sock, client_address):
-        tlsConnection = TLSConnection(sock)
-        if self.handshake(tlsConnection) == True:
-            self.RequestHandlerClass(tlsConnection, client_address, self)
-            tlsConnection.close()
-
-    #Implement this method to do some form of handshaking.  Return True
-    #if the handshake finishes properly and the request is authorized.
-    def handshake(self, tlsConnection):
-        raise NotImplementedError()

gdata/tlslite/integration/TLSTwistedProtocolWrapper.py

@@ -1,196 +0,0 @@
-"""TLS Lite + Twisted."""
-
-from twisted.protocols.policies import ProtocolWrapper, WrappingFactory
-from twisted.python.failure import Failure
-
-from AsyncStateMachine import AsyncStateMachine
-from gdata.tlslite.TLSConnection import TLSConnection
-from gdata.tlslite.errors import *
-
-import socket
-import errno
-
-
-#The TLSConnection is created around a "fake socket" that
-#plugs it into the underlying Twisted transport
-class _FakeSocket:
-    def __init__(self, wrapper):
-        self.wrapper = wrapper
-        self.data = ""
-
-    def send(self, data):
-        ProtocolWrapper.write(self.wrapper, data)
-        return len(data)
-
-    def recv(self, numBytes):
-        if self.data == "":
-            raise socket.error, (errno.EWOULDBLOCK, "")
-        returnData = self.data[:numBytes]
-        self.data = self.data[numBytes:]
-        return returnData
-
-class TLSTwistedProtocolWrapper(ProtocolWrapper, AsyncStateMachine):
-    """This class can wrap Twisted protocols to add TLS support.
-
-    Below is a complete example of using TLS Lite with a Twisted echo
-    server.
-
-    There are two server implementations below.  Echo is the original
-    protocol, which is oblivious to TLS.  Echo1 subclasses Echo and
-    negotiates TLS when the client connects.  Echo2 subclasses Echo and
-    negotiates TLS when the client sends "STARTTLS"::
-
-        from twisted.internet.protocol import Protocol, Factory
-        from twisted.internet import reactor
-        from twisted.protocols.policies import WrappingFactory
-        from twisted.protocols.basic import LineReceiver
-        from twisted.python import log
-        from twisted.python.failure import Failure
-        import sys
-        from tlslite.api import *
-
-        s = open("./serverX509Cert.pem").read()
-        x509 = X509()
-        x509.parse(s)
-        certChain = X509CertChain([x509])
-
-        s = open("./serverX509Key.pem").read()
-        privateKey = parsePEMKey(s, private=True)
-
-        verifierDB = VerifierDB("verifierDB")
-        verifierDB.open()
-
-        class Echo(LineReceiver):
-            def connectionMade(self):
-                self.transport.write("Welcome to the echo server!\\r\\n")
-
-            def lineReceived(self, line):
-                self.transport.write(line + "\\r\\n")
-
-        class Echo1(Echo):
-            def connectionMade(self):
-                if not self.transport.tlsStarted:
-                    self.transport.setServerHandshakeOp(certChain=certChain,
-                                                        privateKey=privateKey,
-                                                        verifierDB=verifierDB)
-                else:
-                    Echo.connectionMade(self)
-
-            def connectionLost(self, reason):
-                pass #Handle any TLS exceptions here
-
-        class Echo2(Echo):
-            def lineReceived(self, data):
-                if data == "STARTTLS":
-                    self.transport.setServerHandshakeOp(certChain=certChain,
-                                                        privateKey=privateKey,
-                                                        verifierDB=verifierDB)
-                else:
-                    Echo.lineReceived(self, data)
-
-            def connectionLost(self, reason):
-                pass #Handle any TLS exceptions here
-
-        factory = Factory()
-        factory.protocol = Echo1
-        #factory.protocol = Echo2
-
-        wrappingFactory = WrappingFactory(factory)
-        wrappingFactory.protocol = TLSTwistedProtocolWrapper
-
-        log.startLogging(sys.stdout)
-        reactor.listenTCP(1079, wrappingFactory)
-        reactor.run()
-
-    This class works as follows:
-
-    Data comes in and is given to the AsyncStateMachine for handling.
-    AsyncStateMachine will forward events to this class, and we'll
-    pass them on to the ProtocolHandler, which will proxy them to the
-    wrapped protocol.  The wrapped protocol may then call back into
-    this class, and these calls will be proxied into the
-    AsyncStateMachine.
-
-    The call graph looks like this:
-     - self.dataReceived
-       - AsyncStateMachine.inReadEvent
-         - self.out(Connect|Close|Read)Event
-           - ProtocolWrapper.(connectionMade|loseConnection|dataReceived)
-             - self.(loseConnection|write|writeSequence)
-               - AsyncStateMachine.(setCloseOp|setWriteOp)
-    """
-
-    #WARNING: IF YOU COPY-AND-PASTE THE ABOVE CODE, BE SURE TO REMOVE
-    #THE EXTRA ESCAPING AROUND "\\r\\n"
-
-    def __init__(self, factory, wrappedProtocol):
-        ProtocolWrapper.__init__(self, factory, wrappedProtocol)
-        AsyncStateMachine.__init__(self)
-        self.fakeSocket = _FakeSocket(self)
-        self.tlsConnection = TLSConnection(self.fakeSocket)
-        self.tlsStarted = False
-        self.connectionLostCalled = False
-
-    def connectionMade(self):
-        try:
-            ProtocolWrapper.connectionMade(self)
-        except TLSError, e:
-            self.connectionLost(Failure(e))
-            ProtocolWrapper.loseConnection(self)
-
-    def dataReceived(self, data):
-        try:
-            if not self.tlsStarted:
-                ProtocolWrapper.dataReceived(self, data)
-            else:
-                self.fakeSocket.data += data
-                while self.fakeSocket.data:
-                    AsyncStateMachine.inReadEvent(self)
-        except TLSError, e:
-            self.connectionLost(Failure(e))
-            ProtocolWrapper.loseConnection(self)
-
-    def connectionLost(self, reason):
-        if not self.connectionLostCalled:
-            ProtocolWrapper.connectionLost(self, reason)
-            self.connectionLostCalled = True
-
-
-    def outConnectEvent(self):
-        ProtocolWrapper.connectionMade(self)
-
-    def outCloseEvent(self):
-        ProtocolWrapper.loseConnection(self)
-
-    def outReadEvent(self, data):
-        if data == "":
-            ProtocolWrapper.loseConnection(self)
-        else:
-            ProtocolWrapper.dataReceived(self, data)
-
-
-    def setServerHandshakeOp(self, **args):
-        self.tlsStarted = True
-        AsyncStateMachine.setServerHandshakeOp(self, **args)
-
-    def loseConnection(self):
-        if not self.tlsStarted:
-            ProtocolWrapper.loseConnection(self)
-        else:
-            AsyncStateMachine.setCloseOp(self)
-
-    def write(self, data):
-        if not self.tlsStarted:
-            ProtocolWrapper.write(self, data)
-        else:
-            #Because of the FakeSocket, write operations are guaranteed to
-            #terminate immediately.
-            AsyncStateMachine.setWriteOp(self, data)
-
-    def writeSequence(self, seq):
-        if not self.tlsStarted:
-            ProtocolWrapper.writeSequence(self, seq)
-        else:
-            #Because of the FakeSocket, write operations are guaranteed to
-            #terminate immediately.
-            AsyncStateMachine.setWriteOp(self, "".join(seq))

gdata/tlslite/integration/XMLRPCTransport.py

@@ -1,137 +0,0 @@
-"""TLS Lite + xmlrpclib."""
-
-import xmlrpclib
-import httplib
-from gdata.tlslite.integration.HTTPTLSConnection import HTTPTLSConnection
-from gdata.tlslite.integration.ClientHelper import ClientHelper
-
-
-class XMLRPCTransport(xmlrpclib.Transport, ClientHelper):
-    """Handles an HTTPS transaction to an XML-RPC server."""
-
-    def __init__(self,
-                 username=None, password=None, sharedKey=None,
-                 certChain=None, privateKey=None,
-                 cryptoID=None, protocol=None,
-                 x509Fingerprint=None,
-                 x509TrustList=None, x509CommonName=None,
-                 settings=None):
-        """Create a new XMLRPCTransport.
-
-        An instance of this class can be passed to L{xmlrpclib.ServerProxy}
-        to use TLS with XML-RPC calls::
-
-            from tlslite.api import XMLRPCTransport
-            from xmlrpclib import ServerProxy
-
-            transport = XMLRPCTransport(user="alice", password="abra123")
-            server = ServerProxy("https://localhost", transport)
-
-        For client authentication, use one of these argument
-        combinations:
-         - username, password (SRP)
-         - username, sharedKey (shared-key)
-         - certChain, privateKey (certificate)
-
-        For server authentication, you can either rely on the
-        implicit mutual authentication performed by SRP or
-        shared-keys, or you can do certificate-based server
-        authentication with one of these argument combinations:
-         - cryptoID[, protocol] (requires cryptoIDlib)
-         - x509Fingerprint
-         - x509TrustList[, x509CommonName] (requires cryptlib_py)
-
-        Certificate-based server authentication is compatible with
-        SRP or certificate-based client authentication.  It is
-        not compatible with shared-keys.
-
-        The constructor does not perform the TLS handshake itself, but
-        simply stores these arguments for later.  The handshake is
-        performed only when this class needs to connect with the
-        server.  Thus you should be prepared to handle TLS-specific
-        exceptions when calling methods of L{xmlrpclib.ServerProxy}.  See the
-        client handshake functions in
-        L{tlslite.TLSConnection.TLSConnection} for details on which
-        exceptions might be raised.
-
-        @type username: str
-        @param username: SRP or shared-key username.  Requires the
-        'password' or 'sharedKey' argument.
-
-        @type password: str
-        @param password: SRP password for mutual authentication.
-        Requires the 'username' argument.
-
-        @type sharedKey: str
-        @param sharedKey: Shared key for mutual authentication.
-        Requires the 'username' argument.
-
-        @type certChain: L{tlslite.X509CertChain.X509CertChain} or
-        L{cryptoIDlib.CertChain.CertChain}
-        @param certChain: Certificate chain for client authentication.
-        Requires the 'privateKey' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type privateKey: L{tlslite.utils.RSAKey.RSAKey}
-        @param privateKey: Private key for client authentication.
-        Requires the 'certChain' argument.  Excludes the SRP or
-        shared-key related arguments.
-
-        @type cryptoID: str
-        @param cryptoID: cryptoID for server authentication.  Mutually
-        exclusive with the 'x509...' arguments.
-
-        @type protocol: str
-        @param protocol: cryptoID protocol URI for server
-        authentication.  Requires the 'cryptoID' argument.
-
-        @type x509Fingerprint: str
-        @param x509Fingerprint: Hex-encoded X.509 fingerprint for
-        server authentication.  Mutually exclusive with the 'cryptoID'
-        and 'x509TrustList' arguments.
-
-        @type x509TrustList: list of L{tlslite.X509.X509}
-        @param x509TrustList: A list of trusted root certificates.  The
-        other party must present a certificate chain which extends to
-        one of these root certificates.  The cryptlib_py module must be
-        installed to use this parameter.  Mutually exclusive with the
-        'cryptoID' and 'x509Fingerprint' arguments.
-
-        @type x509CommonName: str
-        @param x509CommonName: The end-entity certificate's 'CN' field
-        must match this value.  For a web server, this is typically a
-        server name such as 'www.amazon.com'.  Mutually exclusive with
-        the 'cryptoID' and 'x509Fingerprint' arguments.  Requires the
-        'x509TrustList' argument.
-
-        @type settings: L{tlslite.HandshakeSettings.HandshakeSettings}
-        @param settings: Various settings which can be used to control
-        the ciphersuites, certificate types, and SSL/TLS versions
-        offered by the client.
-        """
-
-        ClientHelper.__init__(self,
-                 username, password, sharedKey,
-                 certChain, privateKey,
-                 cryptoID, protocol,
-                 x509Fingerprint,
-                 x509TrustList, x509CommonName,
-                 settings)
-
-
-    def make_connection(self, host):
-        # create a HTTPS connection object from a host descriptor
-        host, extra_headers, x509 = self.get_host_info(host)
-        http = HTTPTLSConnection(host, None,
-                                 self.username, self.password,
-                                 self.sharedKey,
-                                 self.certChain, self.privateKey,
-                                 self.checker.cryptoID,
-                                 self.checker.protocol,
-                                 self.checker.x509Fingerprint,
-                                 self.checker.x509TrustList,
-                                 self.checker.x509CommonName,
-                                 self.settings)
-        http2 = httplib.HTTP()
-        http2._setup(http)
-        return http2

gdata/tlslite/integration/__init__.py

@@ -1,17 +0,0 @@
-"""Classes for integrating TLS Lite with other packages."""
-
-__all__ = ["AsyncStateMachine",
-           "HTTPTLSConnection",
-           "POP3_TLS",
-           "IMAP4_TLS",
-           "SMTP_TLS",
-           "XMLRPCTransport",
-           "TLSSocketServerMixIn",
-           "TLSAsyncDispatcherMixIn",
-           "TLSTwistedProtocolWrapper"]
-
-try:
-    import twisted
-    del twisted
-except ImportError:
-   del __all__[__all__.index("TLSTwistedProtocolWrapper")]

gdata/tlslite/mathtls.py

@@ -1,170 +0,0 @@
-"""Miscellaneous helper functions."""
-
-from utils.compat import *
-from utils.cryptomath import *
-
-import hmac
-import md5
-import sha
-
-#1024, 1536, 2048, 3072, 4096, 6144, and 8192 bit groups]
-goodGroupParameters = [(2,0xEEAF0AB9ADB38DD69C33F80AFA8FC5E86072618775FF3C0B9EA2314C9C256576D674DF7496EA81D3383B4813D692C6E0E0D5D8E250B98BE48E495C1D6089DAD15DC7D7B46154D6B6CE8EF4AD69B15D4982559B297BCF1885C529F566660E57EC68EDBC3C05726CC02FD4CBF4976EAA9AFD5138FE8376435B9FC61D2FC0EB06E3),\
-                       (2,0x9DEF3CAFB939277AB1F12A8617A47BBBDBA51DF499AC4C80BEEEA9614B19CC4D5F4F5F556E27CBDE51C6A94BE4607A291558903BA0D0F84380B655BB9A22E8DCDF028A7CEC67F0D08134B1C8B97989149B609E0BE3BAB63D47548381DBC5B1FC764E3F4B53DD9DA1158BFD3E2B9C8CF56EDF019539349627DB2FD53D24B7C48665772E437D6C7F8CE442734AF7CCB7AE837C264AE3A9BEB87F8A2FE9B8B5292E5A021FFF5E91479E8CE7A28C2442C6F315180F93499A234DCF76E3FED135F9BB),\
-                       (2,0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73),\
-                       (2,0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF),\
-                       (5,0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199FFFFFFFFFFFFFFFF),\
-                       (5,0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C93402849236C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AACC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E6DCC4024FFFFFFFFFFFFFFFF),\
-                       (5,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
-
-def P_hash(hashModule, secret, seed, length):
-    bytes = createByteArrayZeros(length)
-    secret = bytesToString(secret)
-    seed = bytesToString(seed)
-    A = seed
-    index = 0
-    while 1:
-        A = hmac.HMAC(secret, A, hashModule).digest()
-        output = hmac.HMAC(secret, A+seed, hashModule).digest()
-        for c in output:
-            if index >= length:
-                return bytes
-            bytes[index] = ord(c)
-            index += 1
-    return bytes
-
-def PRF(secret, label, seed, length):
-    #Split the secret into left and right halves
-    S1 = secret[ : int(math.ceil(len(secret)/2.0))]
-    S2 = secret[ int(math.floor(len(secret)/2.0)) : ]
-
-    #Run the left half through P_MD5 and the right half through P_SHA1
-    p_md5 = P_hash(md5, S1, concatArrays(stringToBytes(label), seed), length)
-    p_sha1 = P_hash(sha, S2, concatArrays(stringToBytes(label), seed), length)
-
-    #XOR the output values and return the result
-    for x in range(length):
-        p_md5[x] ^= p_sha1[x]
-    return p_md5
-
-
-def PRF_SSL(secret, seed, length):
-    secretStr = bytesToString(secret)
-    seedStr = bytesToString(seed)
-    bytes = createByteArrayZeros(length)
-    index = 0
-    for x in range(26):
-        A = chr(ord('A')+x) * (x+1) # 'A', 'BB', 'CCC', etc..
-        input = secretStr + sha.sha(A + secretStr + seedStr).digest()
-        output = md5.md5(input).digest()
-        for c in output:
-            if index >= length:
-                return bytes
-            bytes[index] = ord(c)
-            index += 1
-    return bytes
-
-def makeX(salt, username, password):
-    if len(username)>=256:
-        raise ValueError("username too long")
-    if len(salt)>=256:
-        raise ValueError("salt too long")
-    return stringToNumber(sha.sha(salt + sha.sha(username + ":" + password)\
-           .digest()).digest())
-
-#This function is used by VerifierDB.makeVerifier
-def makeVerifier(username, password, bits):
-    bitsIndex = {1024:0, 1536:1, 2048:2, 3072:3, 4096:4, 6144:5, 8192:6}[bits]
-    g,N = goodGroupParameters[bitsIndex]
-    salt = bytesToString(getRandomBytes(16))
-    x = makeX(salt, username, password)
-    verifier = powMod(g, x, N)
-    return N, g, salt, verifier
-
-def PAD(n, x):
-    nLength = len(numberToString(n))
-    s = numberToString(x)
-    if len(s) < nLength:
-        s = ("\0" * (nLength-len(s))) + s
-    return s
-
-def makeU(N, A, B):
-  return stringToNumber(sha.sha(PAD(N, A) + PAD(N, B)).digest())
-
-def makeK(N, g):
-  return stringToNumber(sha.sha(numberToString(N) + PAD(N, g)).digest())
-
-
-"""
-MAC_SSL
-Modified from Python HMAC by Trevor
-"""
-
-class MAC_SSL:
-    """MAC_SSL class.
-
-    This supports the API for Cryptographic Hash Functions (PEP 247).
-    """
-
-    def __init__(self, key, msg = None, digestmod = None):
-        """Create a new MAC_SSL object.
-
-        key:       key for the keyed hash object.
-        msg:       Initial input for the hash, if provided.
-        digestmod: A module supporting PEP 247. Defaults to the md5 module.
-        """
-        if digestmod is None:
-            import md5
-            digestmod = md5
-
-        if key == None: #TREVNEW - for faster copying
-            return      #TREVNEW
-
-        self.digestmod = digestmod
-        self.outer = digestmod.new()
-        self.inner = digestmod.new()
-        self.digest_size = digestmod.digest_size
-
-        ipad = "\x36" * 40
-        opad = "\x5C" * 40
-
-        self.inner.update(key)
-        self.inner.update(ipad)
-        self.outer.update(key)
-        self.outer.update(opad)
-        if msg is not None:
-            self.update(msg)
-
-
-    def update(self, msg):
-        """Update this hashing object with the string msg.
-        """
-        self.inner.update(msg)
-
-    def copy(self):
-        """Return a separate copy of this hashing object.
-
-        An update to this copy won't affect the original object.
-        """
-        other = MAC_SSL(None) #TREVNEW - for faster copying
-        other.digest_size = self.digest_size #TREVNEW
-        other.digestmod = self.digestmod
-        other.inner = self.inner.copy()
-        other.outer = self.outer.copy()
-        return other
-
-    def digest(self):
-        """Return the hash value of this hashing object.
-
-        This returns a string containing 8-bit data.  The object is
-        not altered in any way by this function; you can continue
-        updating the object after calling this function.
-        """
-        h = self.outer.copy()
-        h.update(self.inner.digest())
-        return h.digest()
-
-    def hexdigest(self):
-        """Like digest(), but returns a string of hexadecimal digits instead.
-        """
-        return "".join([hex(ord(x))[2:].zfill(2)
-                        for x in tuple(self.digest())])

gdata/tlslite/messages.py

@@ -1,561 +0,0 @@
-"""Classes representing TLS messages."""
-
-from utils.compat import *
-from utils.cryptomath import *
-from errors import *
-from utils.codec import *
-from constants import *
-from X509 import X509
-from X509CertChain import X509CertChain
-
-import sha
-import md5
-
-class RecordHeader3:
-    def __init__(self):
-        self.type = 0
-        self.version = (0,0)
-        self.length = 0
-        self.ssl2 = False
-
-    def create(self, version, type, length):
-        self.type = type
-        self.version = version
-        self.length = length
-        return self
-
-    def write(self):
-        w = Writer(5)
-        w.add(self.type, 1)
-        w.add(self.version[0], 1)
-        w.add(self.version[1], 1)
-        w.add(self.length, 2)
-        return w.bytes
-
-    def parse(self, p):
-        self.type = p.get(1)
-        self.version = (p.get(1), p.get(1))
-        self.length = p.get(2)
-        self.ssl2 = False
-        return self
-
-class RecordHeader2:
-    def __init__(self):
-        self.type = 0
-        self.version = (0,0)
-        self.length = 0
-        self.ssl2 = True
-
-    def parse(self, p):
-        if p.get(1)!=128:
-            raise SyntaxError()
-        self.type = ContentType.handshake
-        self.version = (2,0)
-        #We don't support 2-byte-length-headers; could be a problem
-        self.length = p.get(1)
-        return self
-
-
-class Msg:
-    def preWrite(self, trial):
-        if trial:
-            w = Writer()
-        else:
-            length = self.write(True)
-            w = Writer(length)
-        return w
-
-    def postWrite(self, w, trial):
-        if trial:
-            return w.index
-        else:
-            return w.bytes
-
-class Alert(Msg):
-    def __init__(self):
-        self.contentType = ContentType.alert
-        self.level = 0
-        self.description = 0
-
-    def create(self, description, level=AlertLevel.fatal):
-        self.level = level
-        self.description = description
-        return self
-
-    def parse(self, p):
-        p.setLengthCheck(2)
-        self.level = p.get(1)
-        self.description = p.get(1)
-        p.stopLengthCheck()
-        return self
-
-    def write(self):
-        w = Writer(2)
-        w.add(self.level, 1)
-        w.add(self.description, 1)
-        return w.bytes
-
-
-class HandshakeMsg(Msg):
-    def preWrite(self, handshakeType, trial):
-        if trial:
-            w = Writer()
-            w.add(handshakeType, 1)
-            w.add(0, 3)
-        else:
-            length = self.write(True)
-            w = Writer(length)
-            w.add(handshakeType, 1)
-            w.add(length-4, 3)
-        return w
-
-
-class ClientHello(HandshakeMsg):
-    def __init__(self, ssl2=False):
-        self.contentType = ContentType.handshake
-        self.ssl2 = ssl2
-        self.client_version = (0,0)
-        self.random = createByteArrayZeros(32)
-        self.session_id = createByteArraySequence([])
-        self.cipher_suites = []         # a list of 16-bit values
-        self.certificate_types = [CertificateType.x509]
-        self.compression_methods = []   # a list of 8-bit values
-        self.srp_username = None        # a string
-
-    def create(self, version, random, session_id, cipher_suites,
-               certificate_types=None, srp_username=None):
-        self.client_version = version
-        self.random = random
-        self.session_id = session_id
-        self.cipher_suites = cipher_suites
-        self.certificate_types = certificate_types
-        self.compression_methods = [0]
-        self.srp_username = srp_username
-        return self
-
-    def parse(self, p):
-        if self.ssl2:
-            self.client_version = (p.get(1), p.get(1))
-            cipherSpecsLength = p.get(2)
-            sessionIDLength = p.get(2)
-            randomLength = p.get(2)
-            self.cipher_suites = p.getFixList(3, int(cipherSpecsLength/3))
-            self.session_id = p.getFixBytes(sessionIDLength)
-            self.random = p.getFixBytes(randomLength)
-            if len(self.random) < 32:
-                zeroBytes = 32-len(self.random)
-                self.random = createByteArrayZeros(zeroBytes) + self.random
-            self.compression_methods = [0]#Fake this value
-
-            #We're not doing a stopLengthCheck() for SSLv2, oh well..
-        else:
-            p.startLengthCheck(3)
-            self.client_version = (p.get(1), p.get(1))
-            self.random = p.getFixBytes(32)
-            self.session_id = p.getVarBytes(1)
-            self.cipher_suites = p.getVarList(2, 2)
-            self.compression_methods = p.getVarList(1, 1)
-            if not p.atLengthCheck():
-                totalExtLength = p.get(2)
-                soFar = 0
-                while soFar != totalExtLength:
-                    extType = p.get(2)
-                    extLength = p.get(2)
-                    if extType == 6:
-                        self.srp_username = bytesToString(p.getVarBytes(1))
-                    elif extType == 7:
-                        self.certificate_types = p.getVarList(1, 1)
-                    else:
-                        p.getFixBytes(extLength)
-                    soFar += 4 + extLength
-            p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = HandshakeMsg.preWrite(self, HandshakeType.client_hello, trial)
-        w.add(self.client_version[0], 1)
-        w.add(self.client_version[1], 1)
-        w.addFixSeq(self.random, 1)
-        w.addVarSeq(self.session_id, 1, 1)
-        w.addVarSeq(self.cipher_suites, 2, 2)
-        w.addVarSeq(self.compression_methods, 1, 1)
-
-        extLength = 0
-        if self.certificate_types and self.certificate_types != \
-                [CertificateType.x509]:
-            extLength += 5 + len(self.certificate_types)
-        if self.srp_username:
-            extLength += 5 + len(self.srp_username)
-        if extLength > 0:
-            w.add(extLength, 2)
-
-        if self.certificate_types and self.certificate_types != \
-                [CertificateType.x509]:
-            w.add(7, 2)
-            w.add(len(self.certificate_types)+1, 2)
-            w.addVarSeq(self.certificate_types, 1, 1)
-        if self.srp_username:
-            w.add(6, 2)
-            w.add(len(self.srp_username)+1, 2)
-            w.addVarSeq(stringToBytes(self.srp_username), 1, 1)
-
-        return HandshakeMsg.postWrite(self, w, trial)
-
-
-class ServerHello(HandshakeMsg):
-    def __init__(self):
-        self.contentType = ContentType.handshake
-        self.server_version = (0,0)
-        self.random = createByteArrayZeros(32)
-        self.session_id = createByteArraySequence([])
-        self.cipher_suite = 0
-        self.certificate_type = CertificateType.x509
-        self.compression_method = 0
-
-    def create(self, version, random, session_id, cipher_suite,
-               certificate_type):
-        self.server_version = version
-        self.random = random
-        self.session_id = session_id
-        self.cipher_suite = cipher_suite
-        self.certificate_type = certificate_type
-        self.compression_method = 0
-        return self
-
-    def parse(self, p):
-        p.startLengthCheck(3)
-        self.server_version = (p.get(1), p.get(1))
-        self.random = p.getFixBytes(32)
-        self.session_id = p.getVarBytes(1)
-        self.cipher_suite = p.get(2)
-        self.compression_method = p.get(1)
-        if not p.atLengthCheck():
-            totalExtLength = p.get(2)
-            soFar = 0
-            while soFar != totalExtLength:
-                extType = p.get(2)
-                extLength = p.get(2)
-                if extType == 7:
-                    self.certificate_type = p.get(1)
-                else:
-                    p.getFixBytes(extLength)
-                soFar += 4 + extLength
-        p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = HandshakeMsg.preWrite(self, HandshakeType.server_hello, trial)
-        w.add(self.server_version[0], 1)
-        w.add(self.server_version[1], 1)
-        w.addFixSeq(self.random, 1)
-        w.addVarSeq(self.session_id, 1, 1)
-        w.add(self.cipher_suite, 2)
-        w.add(self.compression_method, 1)
-
-        extLength = 0
-        if self.certificate_type and self.certificate_type != \
-                CertificateType.x509:
-            extLength += 5
-
-        if extLength != 0:
-            w.add(extLength, 2)
-
-        if self.certificate_type and self.certificate_type != \
-                CertificateType.x509:
-            w.add(7, 2)
-            w.add(1, 2)
-            w.add(self.certificate_type, 1)
-
-        return HandshakeMsg.postWrite(self, w, trial)
-
-class Certificate(HandshakeMsg):
-    def __init__(self, certificateType):
-        self.certificateType = certificateType
-        self.contentType = ContentType.handshake
-        self.certChain = None
-
-    def create(self, certChain):
-        self.certChain = certChain
-        return self
-
-    def parse(self, p):
-        p.startLengthCheck(3)
-        if self.certificateType == CertificateType.x509:
-            chainLength = p.get(3)
-            index = 0
-            certificate_list = []
-            while index != chainLength:
-                certBytes = p.getVarBytes(3)
-                x509 = X509()
-                x509.parseBinary(certBytes)
-                certificate_list.append(x509)
-                index += len(certBytes)+3
-            if certificate_list:
-                self.certChain = X509CertChain(certificate_list)
-        elif self.certificateType == CertificateType.cryptoID:
-            s = bytesToString(p.getVarBytes(2))
-            if s:
-                try:
-                    import cryptoIDlib.CertChain
-                except ImportError:
-                    raise SyntaxError(\
-                    "cryptoID cert chain received, cryptoIDlib not present")
-                self.certChain = cryptoIDlib.CertChain.CertChain().parse(s)
-        else:
-            raise AssertionError()
-
-        p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = HandshakeMsg.preWrite(self, HandshakeType.certificate, trial)
-        if self.certificateType == CertificateType.x509:
-            chainLength = 0
-            if self.certChain:
-                certificate_list = self.certChain.x509List
-            else:
-                certificate_list = []
-            #determine length
-            for cert in certificate_list:
-                bytes = cert.writeBytes()
-                chainLength += len(bytes)+3
-            #add bytes
-            w.add(chainLength, 3)
-            for cert in certificate_list:
-                bytes = cert.writeBytes()
-                w.addVarSeq(bytes, 1, 3)
-        elif self.certificateType == CertificateType.cryptoID:
-            if self.certChain:
-                bytes = stringToBytes(self.certChain.write())
-            else:
-                bytes = createByteArraySequence([])
-            w.addVarSeq(bytes, 1, 2)
-        else:
-            raise AssertionError()
-        return HandshakeMsg.postWrite(self, w, trial)
-
-class CertificateRequest(HandshakeMsg):
-    def __init__(self):
-        self.contentType = ContentType.handshake
-        self.certificate_types = []
-        #treat as opaque bytes for now
-        self.certificate_authorities = createByteArraySequence([])
-
-    def create(self, certificate_types, certificate_authorities):
-        self.certificate_types = certificate_types
-        self.certificate_authorities = certificate_authorities
-        return self
-
-    def parse(self, p):
-        p.startLengthCheck(3)
-        self.certificate_types = p.getVarList(1, 1)
-        self.certificate_authorities = p.getVarBytes(2)
-        p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = HandshakeMsg.preWrite(self, HandshakeType.certificate_request,
-                                  trial)
-        w.addVarSeq(self.certificate_types, 1, 1)
-        w.addVarSeq(self.certificate_authorities, 1, 2)
-        return HandshakeMsg.postWrite(self, w, trial)
-
-class ServerKeyExchange(HandshakeMsg):
-    def __init__(self, cipherSuite):
-        self.cipherSuite = cipherSuite
-        self.contentType = ContentType.handshake
-        self.srp_N = 0L
-        self.srp_g = 0L
-        self.srp_s = createByteArraySequence([])
-        self.srp_B = 0L
-        self.signature = createByteArraySequence([])
-
-    def createSRP(self, srp_N, srp_g, srp_s, srp_B):
-        self.srp_N = srp_N
-        self.srp_g = srp_g
-        self.srp_s = srp_s
-        self.srp_B = srp_B
-        return self
-
-    def parse(self, p):
-        p.startLengthCheck(3)
-        self.srp_N = bytesToNumber(p.getVarBytes(2))
-        self.srp_g = bytesToNumber(p.getVarBytes(2))
-        self.srp_s = p.getVarBytes(1)
-        self.srp_B = bytesToNumber(p.getVarBytes(2))
-        if self.cipherSuite in CipherSuite.srpRsaSuites:
-            self.signature = p.getVarBytes(2)
-        p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = HandshakeMsg.preWrite(self, HandshakeType.server_key_exchange,
-                                  trial)
-        w.addVarSeq(numberToBytes(self.srp_N), 1, 2)
-        w.addVarSeq(numberToBytes(self.srp_g), 1, 2)
-        w.addVarSeq(self.srp_s, 1, 1)
-        w.addVarSeq(numberToBytes(self.srp_B), 1, 2)
-        if self.cipherSuite in CipherSuite.srpRsaSuites:
-            w.addVarSeq(self.signature, 1, 2)
-        return HandshakeMsg.postWrite(self, w, trial)
-
-    def hash(self, clientRandom, serverRandom):
-        oldCipherSuite = self.cipherSuite
-        self.cipherSuite = None
-        try:
-            bytes = clientRandom + serverRandom + self.write()[4:]
-            s = bytesToString(bytes)
-            return stringToBytes(md5.md5(s).digest() + sha.sha(s).digest())
-        finally:
-            self.cipherSuite = oldCipherSuite
-
-class ServerHelloDone(HandshakeMsg):
-    def __init__(self):
-        self.contentType = ContentType.handshake
-
-    def create(self):
-        return self
-
-    def parse(self, p):
-        p.startLengthCheck(3)
-        p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = HandshakeMsg.preWrite(self, HandshakeType.server_hello_done, trial)
-        return HandshakeMsg.postWrite(self, w, trial)
-
-class ClientKeyExchange(HandshakeMsg):
-    def __init__(self, cipherSuite, version=None):
-        self.cipherSuite = cipherSuite
-        self.version = version
-        self.contentType = ContentType.handshake
-        self.srp_A = 0
-        self.encryptedPreMasterSecret = createByteArraySequence([])
-
-    def createSRP(self, srp_A):
-        self.srp_A = srp_A
-        return self
-
-    def createRSA(self, encryptedPreMasterSecret):
-        self.encryptedPreMasterSecret = encryptedPreMasterSecret
-        return self
-
-    def parse(self, p):
-        p.startLengthCheck(3)
-        if self.cipherSuite in CipherSuite.srpSuites + \
-                               CipherSuite.srpRsaSuites:
-            self.srp_A = bytesToNumber(p.getVarBytes(2))
-        elif self.cipherSuite in CipherSuite.rsaSuites:
-            if self.version in ((3,1), (3,2)):
-                self.encryptedPreMasterSecret = p.getVarBytes(2)
-            elif self.version == (3,0):
-                self.encryptedPreMasterSecret = \
-                    p.getFixBytes(len(p.bytes)-p.index)
-            else:
-                raise AssertionError()
-        else:
-            raise AssertionError()
-        p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = HandshakeMsg.preWrite(self, HandshakeType.client_key_exchange,
-                                  trial)
-        if self.cipherSuite in CipherSuite.srpSuites + \
-                               CipherSuite.srpRsaSuites:
-            w.addVarSeq(numberToBytes(self.srp_A), 1, 2)
-        elif self.cipherSuite in CipherSuite.rsaSuites:
-            if self.version in ((3,1), (3,2)):
-                w.addVarSeq(self.encryptedPreMasterSecret, 1, 2)
-            elif self.version == (3,0):
-                w.addFixSeq(self.encryptedPreMasterSecret, 1)
-            else:
-                raise AssertionError()
-        else:
-            raise AssertionError()
-        return HandshakeMsg.postWrite(self, w, trial)
-
-class CertificateVerify(HandshakeMsg):
-    def __init__(self):
-        self.contentType = ContentType.handshake
-        self.signature = createByteArraySequence([])
-
-    def create(self, signature):
-        self.signature = signature
-        return self
-
-    def parse(self, p):
-        p.startLengthCheck(3)
-        self.signature = p.getVarBytes(2)
-        p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = HandshakeMsg.preWrite(self, HandshakeType.certificate_verify,
-                                  trial)
-        w.addVarSeq(self.signature, 1, 2)
-        return HandshakeMsg.postWrite(self, w, trial)
-
-class ChangeCipherSpec(Msg):
-    def __init__(self):
-        self.contentType = ContentType.change_cipher_spec
-        self.type = 1
-
-    def create(self):
-        self.type = 1
-        return self
-
-    def parse(self, p):
-        p.setLengthCheck(1)
-        self.type = p.get(1)
-        p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = Msg.preWrite(self, trial)
-        w.add(self.type,1)
-        return Msg.postWrite(self, w, trial)
-
-
-class Finished(HandshakeMsg):
-    def __init__(self, version):
-        self.contentType = ContentType.handshake
-        self.version = version
-        self.verify_data = createByteArraySequence([])
-
-    def create(self, verify_data):
-        self.verify_data = verify_data
-        return self
-
-    def parse(self, p):
-        p.startLengthCheck(3)
-        if self.version == (3,0):
-            self.verify_data = p.getFixBytes(36)
-        elif self.version in ((3,1), (3,2)):
-            self.verify_data = p.getFixBytes(12)
-        else:
-            raise AssertionError()
-        p.stopLengthCheck()
-        return self
-
-    def write(self, trial=False):
-        w = HandshakeMsg.preWrite(self, HandshakeType.finished, trial)
-        w.addFixSeq(self.verify_data, 1)
-        return HandshakeMsg.postWrite(self, w, trial)
-
-class ApplicationData(Msg):
-    def __init__(self):
-        self.contentType = ContentType.application_data
-        self.bytes = createByteArraySequence([])
-
-    def create(self, bytes):
-        self.bytes = bytes
-        return self
-
-    def parse(self, p):
-        self.bytes = p.bytes
-        return self
-
-    def write(self):
-        return self.bytes

gdata/tlslite/utils/AES.py

@@ -1,31 +0,0 @@
-"""Abstract class for AES."""
-
-class AES:
-    def __init__(self, key, mode, IV, implementation):
-        if len(key) not in (16, 24, 32):
-            raise AssertionError()
-        if mode != 2:
-            raise AssertionError()
-        if len(IV) != 16:
-            raise AssertionError()
-        self.isBlockCipher = True
-        self.block_size = 16
-        self.implementation = implementation
-        if len(key)==16:
-            self.name = "aes128"
-        elif len(key)==24:
-            self.name = "aes192"
-        elif len(key)==32:
-            self.name = "aes256"
-        else:
-            raise AssertionError()
-
-    #CBC-Mode encryption, returns ciphertext
-    #WARNING: *MAY* modify the input as well
-    def encrypt(self, plaintext):
-        assert(len(plaintext) % 16 == 0)
-
-    #CBC-Mode decryption, returns plaintext
-    #WARNING: *MAY* modify the input as well
-    def decrypt(self, ciphertext):
-        assert(len(ciphertext) % 16 == 0)

gdata/tlslite/utils/ASN1Parser.py

@@ -1,34 +0,0 @@
-"""Class for parsing ASN.1"""
-from compat import *
-from codec import *
-
-#Takes a byte array which has a DER TLV field at its head
-class ASN1Parser:
-    def __init__(self, bytes):
-        p = Parser(bytes)
-        p.get(1) #skip Type
-
-        #Get Length
-        self.length = self._getASN1Length(p)
-
-        #Get Value
-        self.value = p.getFixBytes(self.length)
-
-    #Assuming this is a sequence...
-    def getChild(self, which):
-        p = Parser(self.value)
-        for x in range(which+1):
-            markIndex = p.index
-            p.get(1) #skip Type
-            length = self._getASN1Length(p)
-            p.getFixBytes(length)
-        return ASN1Parser(p.bytes[markIndex : p.index])
-
-    #Decode the ASN.1 DER length field
-    def _getASN1Length(self, p):
-        firstLength = p.get(1)
-        if firstLength<=127:
-            return firstLength
-        else:
-            lengthLength = firstLength & 0x7F
-            return p.get(lengthLength)

gdata/tlslite/utils/Cryptlib_AES.py

@@ -1,34 +0,0 @@
-"""Cryptlib AES implementation."""
-
-from cryptomath import *
-from AES import *
-
-if cryptlibpyLoaded:
-
-    def new(key, mode, IV):
-        return Cryptlib_AES(key, mode, IV)
-
-    class Cryptlib_AES(AES):
-
-        def __init__(self, key, mode, IV):
-            AES.__init__(self, key, mode, IV, "cryptlib")
-            self.context = cryptlib_py.cryptCreateContext(cryptlib_py.CRYPT_UNUSED, cryptlib_py.CRYPT_ALGO_AES)
-            cryptlib_py.cryptSetAttribute(self.context, cryptlib_py.CRYPT_CTXINFO_MODE, cryptlib_py.CRYPT_MODE_CBC)
-            cryptlib_py.cryptSetAttribute(self.context, cryptlib_py.CRYPT_CTXINFO_KEYSIZE, len(key))
-            cryptlib_py.cryptSetAttributeString(self.context, cryptlib_py.CRYPT_CTXINFO_KEY, key)
-            cryptlib_py.cryptSetAttributeString(self.context, cryptlib_py.CRYPT_CTXINFO_IV, IV)
-
-        def __del__(self):
-             cryptlib_py.cryptDestroyContext(self.context)
-
-        def encrypt(self, plaintext):
-            AES.encrypt(self, plaintext)
-            bytes = stringToBytes(plaintext)
-            cryptlib_py.cryptEncrypt(self.context, bytes)
-            return bytesToString(bytes)
-
-        def decrypt(self, ciphertext):
-            AES.decrypt(self, ciphertext)
-            bytes = stringToBytes(ciphertext)
-            cryptlib_py.cryptDecrypt(self.context, bytes)
-            return bytesToString(bytes)

gdata/tlslite/utils/Cryptlib_RC4.py

@@ -1,28 +0,0 @@
-"""Cryptlib RC4 implementation."""
-
-from cryptomath import *
-from RC4 import RC4
-
-if cryptlibpyLoaded:
-
-    def new(key):
-        return Cryptlib_RC4(key)
-
-    class Cryptlib_RC4(RC4):
-
-        def __init__(self, key):
-            RC4.__init__(self, key, "cryptlib")
-            self.context = cryptlib_py.cryptCreateContext(cryptlib_py.CRYPT_UNUSED, cryptlib_py.CRYPT_ALGO_RC4)
-            cryptlib_py.cryptSetAttribute(self.context, cryptlib_py.CRYPT_CTXINFO_KEYSIZE, len(key))
-            cryptlib_py.cryptSetAttributeString(self.context, cryptlib_py.CRYPT_CTXINFO_KEY, key)
-
-        def __del__(self):
-             cryptlib_py.cryptDestroyContext(self.context)
-
-        def encrypt(self, plaintext):
-            bytes = stringToBytes(plaintext)
-            cryptlib_py.cryptEncrypt(self.context, bytes)
-            return bytesToString(bytes)
-
-        def decrypt(self, ciphertext):
-            return self.encrypt(ciphertext)

gdata/tlslite/utils/Cryptlib_TripleDES.py

@@ -1,35 +0,0 @@
-"""Cryptlib 3DES implementation."""
-
-from cryptomath import *
-
-from TripleDES import *
-
-if cryptlibpyLoaded:
-
-    def new(key, mode, IV):
-        return Cryptlib_TripleDES(key, mode, IV)
-
-    class Cryptlib_TripleDES(TripleDES):
-
-        def __init__(self, key, mode, IV):
-            TripleDES.__init__(self, key, mode, IV, "cryptlib")
-            self.context = cryptlib_py.cryptCreateContext(cryptlib_py.CRYPT_UNUSED, cryptlib_py.CRYPT_ALGO_3DES)
-            cryptlib_py.cryptSetAttribute(self.context, cryptlib_py.CRYPT_CTXINFO_MODE, cryptlib_py.CRYPT_MODE_CBC)
-            cryptlib_py.cryptSetAttribute(self.context, cryptlib_py.CRYPT_CTXINFO_KEYSIZE, len(key))
-            cryptlib_py.cryptSetAttributeString(self.context, cryptlib_py.CRYPT_CTXINFO_KEY, key)
-            cryptlib_py.cryptSetAttributeString(self.context, cryptlib_py.CRYPT_CTXINFO_IV, IV)
-
-        def __del__(self):
-             cryptlib_py.cryptDestroyContext(self.context)
-
-        def encrypt(self, plaintext):
-            TripleDES.encrypt(self, plaintext)
-            bytes = stringToBytes(plaintext)
-            cryptlib_py.cryptEncrypt(self.context, bytes)
-            return bytesToString(bytes)
-
-        def decrypt(self, ciphertext):
-            TripleDES.decrypt(self, ciphertext)
-            bytes = stringToBytes(ciphertext)
-            cryptlib_py.cryptDecrypt(self.context, bytes)
-            return bytesToString(bytes)

gdata/tlslite/utils/OpenSSL_AES.py

@@ -1,49 +0,0 @@
-"""OpenSSL/M2Crypto AES implementation."""
-
-from cryptomath import *
-from AES import *
-
-if m2cryptoLoaded:
-
-    def new(key, mode, IV):
-        return OpenSSL_AES(key, mode, IV)
-
-    class OpenSSL_AES(AES):
-
-        def __init__(self, key, mode, IV):
-            AES.__init__(self, key, mode, IV, "openssl")
-            self.key = key
-            self.IV = IV
-
-        def _createContext(self, encrypt):
-            context = m2.cipher_ctx_new()
-            if len(self.key)==16:
-                cipherType = m2.aes_128_cbc()
-            if len(self.key)==24:
-                cipherType = m2.aes_192_cbc()
-            if len(self.key)==32:
-                cipherType = m2.aes_256_cbc()
-            m2.cipher_init(context, cipherType, self.key, self.IV, encrypt)
-            return context
-
-        def encrypt(self, plaintext):
-            AES.encrypt(self, plaintext)
-            context = self._createContext(1)
-            ciphertext = m2.cipher_update(context, plaintext)
-            m2.cipher_ctx_free(context)
-            self.IV = ciphertext[-self.block_size:]
-            return ciphertext
-
-        def decrypt(self, ciphertext):
-            AES.decrypt(self, ciphertext)
-            context = self._createContext(0)
-            #I think M2Crypto has a bug - it fails to decrypt and return the last block passed in.
-            #To work around this, we append sixteen zeros to the string, below:
-            plaintext = m2.cipher_update(context, ciphertext+('\0'*16))
-
-            #If this bug is ever fixed, then plaintext will end up having a garbage
-            #plaintext block on the end.  That's okay - the below code will discard it.
-            plaintext = plaintext[:len(ciphertext)]
-            m2.cipher_ctx_free(context)
-            self.IV = ciphertext[-self.block_size:]
-            return plaintext

gdata/tlslite/utils/OpenSSL_RC4.py

@@ -1,25 +0,0 @@
-"""OpenSSL/M2Crypto RC4 implementation."""
-
-from cryptomath import *
-from RC4 import RC4
-
-if m2cryptoLoaded:
-
-    def new(key):
-        return OpenSSL_RC4(key)
-
-    class OpenSSL_RC4(RC4):
-
-        def __init__(self, key):
-            RC4.__init__(self, key, "openssl")
-            self.rc4 = m2.rc4_new()
-            m2.rc4_set_key(self.rc4, key)
-
-        def __del__(self):
-            m2.rc4_free(self.rc4)
-
-        def encrypt(self, plaintext):
-            return m2.rc4_update(self.rc4, plaintext)
-
-        def decrypt(self, ciphertext):
-            return self.encrypt(ciphertext)