Repository: algorand/pyteal (language: python)

Issue:
Remove redundant test imports
Removes redundant test imports as requested in https://github.com/algorand/pyteal/pull/273#discussion_r849969441.

Unfortunately, I made the changes by hand.  I was unable to craft a sed expression to match the comment + next line _and_ delete.

As a sanity check, here's proof that there ought to be 34 files modified:

```
~/dev/pyteal make-and-flake *1 ?5 ──────────────────────────────────────────────────────────────────────────────────────  pyteal 09:54:15 PM
❯ grep -R "this is not necessary" pyteal | sort | uniq -c
   1 pyteal/ast/acct_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/app_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/arg_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/assert_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/asset_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/binaryexpr_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/break_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/bytes_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/cond_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/continue_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/for_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/gaid_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/gload_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/global_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/if_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/int_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/itxn_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/maybe_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/naryexpr_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/nonce_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/return_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/scratch_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/scratchvar_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/seq_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/subroutine_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/substring_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/ternaryexpr_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/tmpl_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/txn_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/unaryexpr_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ast/while_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/compiler/compiler_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/compiler/flatten_test.py:# this is not necessary but mypy complains if it's not included
   1 pyteal/ir/tealblock_test.py:# this is not necessary but mypy complains if it's not included

~/dev/pyteal make-and-flake *1 ?5 ──────────────────────────────────────────────────────────────────────────────────────  pyteal 09:56:08 PM
❯ grep -R "this is not necessary" pyteal | wc -l
      34
```
Run blackbox tests in CI
Defines `Makefile` facilities to run blackbox tests from #249 as part of the build.


Discussion / hints:

Bringing a comment over from #249 that's better placed here:

> Sync'ed up offline but let's summarize my wish list regarding testing (with the caveat that clearly "testing" is better than "no testing").

> From most desired to least desired (but again, even least desired is really great):

> 1. have a dry run test that doesn't require running a node (a la goal clerk dryrun without the remote option)
> 2. have the dry run test that uses a quickly downloadable pre-built docker image (a la docker pull algorand/stable)
> 3. have a dry run that stands up the minimum necessary sandbox-like environment
> 4. have a dry run that stands up a "heavier" sandbox environment similar to the one that the SDK's do
> Bringing a comment over from #249 that's better placed here:
> 
> > Sync'ed up offline but let's summarize my wish list regarding testing (with the caveat that clearly "testing" is better than "no testing").
> 
> > From most desired to least desired (but again, even least desired is really great):
> 
> > 1. have a dry run test that doesn't require running a node (a la goal clerk dryrun without the remote option)
> > 2. have the dry run test that uses a quickly downloadable pre-built docker image (a la docker pull algorand/stable)
> > 3. have a dry run that stands up the minimum necessary sandbox-like environment
> > 4. have a dry run that stands up a "heavier" sandbox environment similar to the one that the SDK's do

From my understanding the present solution is an optimized version of **3.**: A simple sandbox is downloaded but it's cached so -in practice- it's almost as good as **2.**

Also, we see from experience that it's taking around 5 minutes to run the tests. It's slower than the 1 minute times we had before the test, but not nearly as bad as the wait times on the SDK's and on `go-algorand`.
Closing - We've evolved these techniques via https://github.com/algorand/graviton/pull/1.  #249 will directly bring in the CI test running. 

Fix patch:
diff --git a/.flake8 b/.flake8
new file mode 100644
index 000000000..7c6dc806e
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,26 @@
+[flake8]
+ignore =
+    E203,
+    E241,
+    W291,
+    E302,
+    E501,
+    W503,
+    E741,
+
+per-file-ignores =
+    pyteal/compiler/optimizer/__init__.py:          F401
+    examples/application/asset.py:                  F403, F405
+    examples/application/security_token.py:         F403, F405
+    examples/application/vote.py:                   F403, F405
+    examples/signature/atomic_swap.py:              F403, F405
+    examples/signature/basic.py:                    F403, F405
+    examples/signature/dutch_auction.py:            F403, F405
+    examples/signature/periodic_payment_deploy.py:  F403, F405
+    examples/signature/recurring_swap.py:           F403, F405
+    examples/signature/split.py:                    F403, F405
+    examples/signature/periodic_payment.py:         F403, F405
+    examples/signature/recurring_swap_deploy.py:    F403, F405
+    pyteal/__init__.py:                             F401, F403
+    pyteal/ir/ops.py:                               E221
+    tests/module_test.py:                           F401, F403
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 387a326ed..4eb3bbd35 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -6,10 +6,11 @@ on:
       - v**
     branches:
       - master
+
 jobs:
   build-test:
     runs-on: ubuntu-20.04
-    container: python:${{ matrix.python }}-slim
+    container: python:${{ matrix.python }}
     strategy:
       matrix:
         python: ['3.10']
@@ -19,16 +20,11 @@ jobs:
         uses: actions/checkout@v2
         with:
           fetch-depth: 0
-      - name: Install pip dependencies
-        run: |
-          pip install -r requirements.txt
-          pip install -e .
+      - name: Install python dependencies
+        run: make setup-development
       - name: Build and Test
-        run: |
-          python scripts/generate_init.py --check
-          black --check .
-          mypy pyteal
-          pytest
+        run: make build-and-test
+
   build-docset:
     runs-on: ubuntu-20.04
     container: python:3.10  # Needs `make`, can't be slim
@@ -37,22 +33,16 @@ jobs:
         uses: actions/checkout@v2
         with:
           fetch-depth: 0
-      - name: Install pip dependencies
-        run: |
-          pip install -r requirements.txt
-          pip install -r docs/requirements.txt
-          pip install doc2dash
+      - name: Install python dependencies
+        run: make setup-docs
       - name: Make docs
-        run: |
-          cd docs
-          make html
-          doc2dash --name pyteal --index-page index.html --online-redirect-url https://pyteal.readthedocs.io/en/ _build/html
-          tar -czvf pyteal.docset.tar.gz pyteal.docset
+        run: make bundle-docs
       - name: Archive docset
         uses: actions/upload-artifact@v2
         with:
           name: pyteal.docset
           path: docs/pyteal.docset.tar.gz
+
   upload-to-pypi:
     runs-on: ubuntu-20.04
     container: python:3.10
@@ -64,9 +54,9 @@ jobs:
         with:
           fetch-depth: 0
       - name: Install dependencies
-        run: pip install wheel
+        run: make setup-wheel
       - name: Build package
-        run: python setup.py sdist bdist_wheel
+        run: make bdist-wheel
       - name: Release
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
diff --git a/.gitignore b/.gitignore
index 3ede576e5..b96db3ef2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,3 @@
-.DS_Store
-
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -54,8 +52,8 @@ coverage.xml
 .pytest_cache/
 
 # Tests generating TEAL output to compared against an expected example.
-tests/teal/*.teal
-!tests/teal/*_expected.teal
+tests/**/*.teal
+!tests/**/*_expected.teal
 
 # Translations
 *.mo
@@ -76,6 +74,7 @@ instance/
 
 # Sphinx documentation
 docs/_build/
+pyteal.docset*
 
 # PyBuilder
 target/
@@ -133,3 +132,6 @@ dmypy.json
 # IDE
 .idea
 .vscode
+
+# mac OS
+.DS_Store
diff --git a/Makefile b/Makefile
new file mode 100644
index 000000000..8e77f54fd
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,49 @@
+setup-development:
+	pip install -e.[development]
+
+setup-docs: setup-development
+	pip install -r docs/requirements.txt
+	pip install doc2dash
+
+setup-wheel:
+	pip install wheel
+
+bdist-wheel:
+	python setup.py sdist bdist_wheel
+
+bundle-docs-clean:
+	rm -rf docs/pyteal.docset
+
+bundle-docs: bundle-docs-clean
+	cd docs && \
+	make html && \
+	doc2dash --name pyteal --index-page index.html --online-redirect-url https://pyteal.readthedocs.io/en/ _build/html && \
+	tar -czvf pyteal.docset.tar.gz pyteal.docset
+
+generate-init:
+	python -m scripts.generate_init
+
+check-generate-init:
+	python -m scripts.generate_init --check
+
+ALLPY = docs examples pyteal scripts tests *.py
+black:
+	black --check $(ALLPY)
+
+flake8:
+	flake8 $(ALLPY)
+
+MYPY = pyteal scripts
+mypy:
+	mypy $(MYPY)
+
+lint: black flake8 mypy
+
+test-unit:
+	pytest
+
+build-and-test: check-generate-init lint test-unit
+
+# Extras:
+coverage:
+	pytest --cov-report html --cov=pyteal
diff --git a/README.md b/README.md
index 0e9f57858..8b5ac2f0f 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,6 @@
-![PyTeal logo](https://github.com/algorand/pyteal/blob/master/docs/pyteal.png?raw=true)
+ <!-- markdownlint-disable-file MD041 -->
 
+![PyTeal logo](https://github.com/algorand/pyteal/blob/master/docs/pyteal.png?raw=true)
 
 # PyTeal: Algorand Smart Contracts in Python
 
@@ -8,27 +9,27 @@
 [![Documentation Status](https://readthedocs.org/projects/pyteal/badge/?version=latest)](https://pyteal.readthedocs.io/en/latest/?badge=latest)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
-PyTeal is a Python language binding for [Algorand Smart Contracts (ASC1s)](https://developer.algorand.org/docs/features/asc1/). 
+PyTeal is a Python language binding for [Algorand Smart Contracts (ASC1s)](https://developer.algorand.org/docs/features/asc1/).
 
-Algorand Smart Contracts are implemented using a new language that is stack-based, 
-called [Transaction Execution Approval Language (TEAL)](https://developer.algorand.org/docs/features/asc1/teal/). 
+Algorand Smart Contracts are implemented using a new language that is stack-based,
+called [Transaction Execution Approval Language (TEAL)](https://developer.algorand.org/docs/features/asc1/teal/).
 
-However, TEAL is essentially an assembly language. With PyTeal, developers can express smart contract logic purely using Python. 
+However, TEAL is essentially an assembly language. With PyTeal, developers can express smart contract logic purely using Python.
 PyTeal provides high level, functional programming style abstractions over TEAL and does type checking at construction time.
 
-### Install 
+## Install
 
 PyTeal requires Python version >= 3.10.
 
 To manage multiple Python versions use tooling like [pyenv](https://github.com/pyenv/pyenv).
 
-#### Recommended: Install from PyPi
+### Recommended: Install from PyPi
 
 Install the latest official release from PyPi:
 
 * `pip install pyteal`
 
-#### Install Latest Commit
+### Install Latest Commit
 
 If needed, it's possible to install directly from the latest commit on master to use unreleased features:
 
@@ -36,31 +37,41 @@ If needed, it's possible to install directly from the latest commit on master to
 
 * `pip install git+https://github.com/algorand/pyteal`
 
-### Documentation
+## Documentation
 
 * [PyTeal Docs](https://pyteal.readthedocs.io/)
 * `docs/` ([README](docs/README.md)) contains raw docs.
 
-### Development Setup
+## Development Setup
 
 Setup venv (one time):
- * `python3 -m venv venv`
+
+* `python3 -m venv venv`
 
 Active venv:
- * `. venv/bin/activate` (if your shell is bash/zsh)
- * `. venv/bin/activate.fish` (if your shell is fish)
 
-Pip install PyTeal in editable state
- * `pip install -e .`
+* `. venv/bin/activate` (if your shell is bash/zsh)
+* `. venv/bin/activate.fish` (if your shell is fish)
+
+Pip install PyTeal in editable state with dependencies:
+
+* `make setup-development`
+* OR if you don't have `make` installed:
+  * `pip install -e.[development]`
+  * Note, that if you're using `zsh` you'll need to escape the brackets: `pip install -e.\[development\]`
 
-Install dependencies:
-* `pip install -r requirements.txt`
- 
 Type checking using mypy:
+
 * `mypy pyteal`
 
 Run tests:
+
 * `pytest`
 
 Format code:
+
 * `black .`
+
+Lint using flake8:
+
+* `flake8 docs examples pyteal scripts tests *.py`
diff --git a/examples/application/vote_deploy.py b/examples/application/vote_deploy.py
index 09b9966b7..6dbec0a05 100644
--- a/examples/application/vote_deploy.py
+++ b/examples/application/vote_deploy.py
@@ -1,7 +1,6 @@
 # based off https://github.com/algorand/docs/blob/cdf11d48a4b1168752e6ccaf77c8b9e8e599713a/examples/smart_contracts/v2/python/stateful_smart_contracts.py
 
 import base64
-import datetime
 
 from algosdk.future import transaction
 from algosdk import account, mnemonic
diff --git a/examples/signature/periodic_payment_deploy.py b/examples/signature/periodic_payment_deploy.py
index 6366e29a5..3882dc5ff 100644
--- a/examples/signature/periodic_payment_deploy.py
+++ b/examples/signature/periodic_payment_deploy.py
@@ -1,9 +1,13 @@
 #!/usr/bin/env python3
 
-from pyteal import *
-import uuid, params, base64
+import base64
+import params
+import uuid
+
 from algosdk import algod, transaction, account, mnemonic
-from periodic_payment import periodic_payment, tmpl_amt
+from periodic_payment import periodic_payment
+
+from pyteal import *
 
 # --------- compile & send transaction using Goal and Python SDK ----------
 
diff --git a/examples/signature/recurring_swap_deploy.py b/examples/signature/recurring_swap_deploy.py
index 536237a52..1293f8b5c 100644
--- a/examples/signature/recurring_swap_deploy.py
+++ b/examples/signature/recurring_swap_deploy.py
@@ -1,11 +1,19 @@
 #!/usr/bin/env python3
 
-from pyteal import *
+import base64
 from nacl import encoding, hash
-from recurring_swap import recurring_swap, tmpl_provider
-from algosdk import algod, account
+import params
+import re
+import time
+import uuid
+
+from algosdk import algod
 from algosdk.future import transaction
-import uuid, params, re, base64, time
+
+from pyteal import *
+
+from recurring_swap import recurring_swap
+
 
 # ------- generate provider's account -----------------------------------------------
 key_fn = str(uuid.uuid4()) + ".key"
diff --git a/pyteal/ast/acct.py b/pyteal/ast/acct.py
index d9c59a8d8..ae8475eae 100644
--- a/pyteal/ast/acct.py
+++ b/pyteal/ast/acct.py
@@ -1,13 +1,8 @@
-from typing import TYPE_CHECKING
-
 from ..types import TealType, require_type
 from ..ir import Op
 from .expr import Expr
 from .maybe import MaybeValue
 
-if TYPE_CHECKING:
-    from ..compiler import CompileOptions
-
 
 class AccountParam:
     @classmethod
diff --git a/pyteal/ast/asset.py b/pyteal/ast/asset.py
index 1d416e787..2ad65c20e 100644
--- a/pyteal/ast/asset.py
+++ b/pyteal/ast/asset.py
@@ -1,9 +1,6 @@
-from enum import Enum
-
 from ..types import TealType, require_type
 from ..ir import Op
 from .expr import Expr
-from .leafexpr import LeafExpr
 from .maybe import MaybeValue
 
 
diff --git a/pyteal/ast/cond.py b/pyteal/ast/cond.py
index 348921b61..60cb097bf 100644
--- a/pyteal/ast/cond.py
+++ b/pyteal/ast/cond.py
@@ -4,8 +4,6 @@
 from ..ir import TealOp, Op, TealSimpleBlock, TealConditionalBlock
 from ..errors import TealInputError
 from .expr import Expr
-from .err import Err
-from .if_ import If
 
 if TYPE_CHECKING:
     from ..compiler import CompileOptions
diff --git a/pyteal/ast/for_.py b/pyteal/ast/for_.py
index 137d71725..d7897253f 100644
--- a/pyteal/ast/for_.py
+++ b/pyteal/ast/for_.py
@@ -4,8 +4,6 @@
 from ..ir import TealSimpleBlock, TealConditionalBlock
 from ..errors import TealCompileError
 from .expr import Expr
-from .seq import Seq
-from .int import Int
 
 if TYPE_CHECKING:
     from ..compiler import CompileOptions
diff --git a/pyteal/ast/gitxn.py b/pyteal/ast/gitxn.py
index 4108d86ff..bbfa687a0 100644
--- a/pyteal/ast/gitxn.py
+++ b/pyteal/ast/gitxn.py
@@ -6,7 +6,6 @@
 from ..ir import TealOp, Op, TealBlock
 from .expr import Expr
 from .txn import TxnExpr, TxnField, TxnObject, TxnaExpr
-from ..types import require_type, TealType
 
 if TYPE_CHECKING:
     from ..compiler import CompileOptions
diff --git a/pyteal/ast/if_.py b/pyteal/ast/if_.py
index 2bb60ab86..389e17de5 100644
--- a/pyteal/ast/if_.py
+++ b/pyteal/ast/if_.py
@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING
 
 from ..errors import TealCompileError, TealInputError
-from ..types import TealType, require_type, types_match
+from ..types import TealType, require_type
 from ..ir import TealSimpleBlock, TealConditionalBlock
 from .expr import Expr
 
diff --git a/pyteal/ast/maybe.py b/pyteal/ast/maybe.py
index e394b4682..9ce9e2521 100644
--- a/pyteal/ast/maybe.py
+++ b/pyteal/ast/maybe.py
@@ -1,4 +1,4 @@
-from typing import List, Union, TYPE_CHECKING
+from typing import List, Union
 
 from pyteal.ast.multi import MultiValue
 
@@ -7,9 +7,6 @@
 from .expr import Expr
 from .scratch import ScratchLoad, ScratchSlot
 
-if TYPE_CHECKING:
-    from ..compiler import CompileOptions
-
 
 class MaybeValue(MultiValue):
     """Represents a get operation returning a value that may not exist."""
diff --git a/pyteal/ast/methodsig.py b/pyteal/ast/methodsig.py
index de9bd9748..b10e03b49 100644
--- a/pyteal/ast/methodsig.py
+++ b/pyteal/ast/methodsig.py
@@ -1,10 +1,9 @@
 from typing import TYPE_CHECKING
-from pyteal.errors import TealInputError
-
-from pyteal.types import TealType
 
+from ..errors import TealInputError
 from ..types import TealType
 from ..ir import TealOp, Op, TealBlock
+
 from .leafexpr import LeafExpr
 
 if TYPE_CHECKING:
diff --git a/pyteal/ast/substring.py b/pyteal/ast/substring.py
index 3167484a7..a9fd8b1f8 100644
--- a/pyteal/ast/substring.py
+++ b/pyteal/ast/substring.py
@@ -1,5 +1,4 @@
-from enum import Enum
-from typing import cast, Tuple, TYPE_CHECKING
+from typing import cast, TYPE_CHECKING
 
 from ..types import TealType, require_type
 from ..errors import TealCompileError, verifyTealVersion
diff --git a/pyteal/ast/ternaryexpr.py b/pyteal/ast/ternaryexpr.py
index 94776e800..f07939c4a 100644
--- a/pyteal/ast/ternaryexpr.py
+++ b/pyteal/ast/ternaryexpr.py
@@ -4,8 +4,6 @@
 from ..errors import verifyTealVersion
 from ..ir import TealOp, Op, TealBlock
 from .expr import Expr
-from .int import Int
-from .unaryexpr import Len
 
 if TYPE_CHECKING:
     from ..compiler import CompileOptions
diff --git a/pyteal/ast/tmpl.py b/pyteal/ast/tmpl.py
index b311dc448..9f6b0a99c 100644
--- a/pyteal/ast/tmpl.py
+++ b/pyteal/ast/tmpl.py
@@ -2,7 +2,6 @@
 
 from ..types import TealType, valid_tmpl
 from ..ir import TealOp, Op, TealBlock
-from ..errors import TealInternalError
 from .leafexpr import LeafExpr
 
 if TYPE_CHECKING:
diff --git a/pyteal/ast/while_.py b/pyteal/ast/while_.py
index be90d59fa..f920c738c 100644
--- a/pyteal/ast/while_.py
+++ b/pyteal/ast/while_.py
@@ -4,7 +4,6 @@
 from ..types import TealType, require_type
 from ..ir import TealSimpleBlock, TealConditionalBlock
 from .expr import Expr
-from .seq import Seq
 
 if TYPE_CHECKING:
     from ..compiler import CompileOptions
diff --git a/pyteal/ast/widemath.py b/pyteal/ast/widemath.py
index 5b7fd756a..25a0914ab 100644
--- a/pyteal/ast/widemath.py
+++ b/pyteal/ast/widemath.py
@@ -1,8 +1,8 @@
 from typing import List, Tuple, TYPE_CHECKING
 
-from ..types import TealType, require_type
-from ..errors import TealInputError, TealInternalError, TealCompileError
-from ..ir import TealOp, Op, TealSimpleBlock, TealBlock
+from ..types import TealType
+from ..errors import TealInternalError, TealCompileError
+from ..ir import TealOp, Op, TealSimpleBlock
 from .expr import Expr
 
 if TYPE_CHECKING:
diff --git a/pyteal/compiler/flatten.py b/pyteal/compiler/flatten.py
index 95454f1b2..96cbebece 100644
--- a/pyteal/compiler/flatten.py
+++ b/pyteal/compiler/flatten.py
@@ -1,4 +1,4 @@
-from typing import List, Dict, DefaultDict, Optional, cast
+from typing import List, Dict, DefaultDict, Optional
 from collections import defaultdict
 
 from ..ast import SubroutineDefinition
diff --git a/pyteal/compiler/scratchslots.py b/pyteal/compiler/scratchslots.py
index 91198d979..bdc9d45a8 100644
--- a/pyteal/compiler/scratchslots.py
+++ b/pyteal/compiler/scratchslots.py
@@ -1,8 +1,8 @@
 from typing import Tuple, Set, Dict, Optional, cast
 
 from ..ast import ScratchSlot, SubroutineDefinition
-from ..ir import Mode, TealComponent, TealBlock, Op
-from ..errors import TealInputError, TealInternalError
+from ..ir import TealBlock, Op
+from ..errors import TealInternalError
 from ..config import NUM_SLOTS
 
 
diff --git a/pyteal/compiler/subroutines.py b/pyteal/compiler/subroutines.py
index 23122ccfd..0fff331e8 100644
--- a/pyteal/compiler/subroutines.py
+++ b/pyteal/compiler/subroutines.py
@@ -1,7 +1,6 @@
 import re
 from typing import List, Dict, Set, Optional, TypeVar
 from collections import OrderedDict
-from itertools import chain
 
 from ..errors import TealInputError
 from ..types import TealType
diff --git a/pyteal/errors.py b/pyteal/errors.py
index a32cb4d5a..4093819dd 100644
--- a/pyteal/errors.py
+++ b/pyteal/errors.py
@@ -1,4 +1,4 @@
-from typing import List, Optional, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from .ast import Expr
diff --git a/pyteal/ir/tealblock.py b/pyteal/ir/tealblock.py
index 27b8d778a..01284506a 100644
--- a/pyteal/ir/tealblock.py
+++ b/pyteal/ir/tealblock.py
@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Optional, List, Tuple, Set, Iterator, cast, TYPE_CHECKING
+from typing import List, Tuple, Set, Iterator, cast, TYPE_CHECKING
 
 from .tealop import TealOp, Op
 from ..errors import TealCompileError
diff --git a/pyteal/ir/tealconditionalblock.py b/pyteal/ir/tealconditionalblock.py
index d86d8b035..bfbb3065c 100644
--- a/pyteal/ir/tealconditionalblock.py
+++ b/pyteal/ir/tealconditionalblock.py
@@ -1,4 +1,4 @@
-from typing import Optional, List, cast
+from typing import Optional, List
 
 from .tealop import TealOp
 from .tealblock import TealBlock
diff --git a/pyteal/ir/tealsimpleblock.py b/pyteal/ir/tealsimpleblock.py
index 485e4c6e6..6bd0285ab 100644
--- a/pyteal/ir/tealsimpleblock.py
+++ b/pyteal/ir/tealsimpleblock.py
@@ -1,4 +1,4 @@
-from typing import Optional, List, cast
+from typing import Optional, List
 
 from .tealop import TealOp
 from .tealblock import TealBlock
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index c0d217cf1..000000000
--- a/requirements.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-black==22.3.0
-mypy==0.931
-pytest
-pytest-timeout
-py-algorand-sdk
diff --git a/scripts/generate_init.py b/scripts/generate_init.py
index e9a1c85e6..8f5730e04 100644
--- a/scripts/generate_init.py
+++ b/scripts/generate_init.py
@@ -1,5 +1,8 @@
-import argparse, os, sys, difflib
+import argparse
 from collections import Counter
+import difflib
+import os
+import sys
 
 from pyteal import __all__ as static_all
 
diff --git a/setup.py b/setup.py
index 0cd848b0c..8d2d3103c 100644
--- a/setup.py
+++ b/setup.py
@@ -16,6 +16,16 @@
     url="https://github.com/algorand/pyteal",
     packages=setuptools.find_packages(),
     install_requires=["py-algorand-sdk"],
+    extras_require={
+        "development": [
+            "black==22.3.0",
+            "flake8==4.0.1",
+            "mypy==0.942",
+            "pytest==7.1.1",
+            "pytest-cov==3.0.0",
+            "pytest-timeout==2.1.0",
+        ],
+    },
     classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: MIT License",


Test patch:
diff --git a/pyteal/ast/acct_test.py b/pyteal/ast/acct_test.py
index 84af5cf07..52fc89132 100644
--- a/pyteal/ast/acct_test.py
+++ b/pyteal/ast/acct_test.py
@@ -1,80 +1,75 @@
-import pytest
+import pyteal as pt
 
-from .. import *
-
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
-teal4Options = CompileOptions(version=4)
-teal5Options = CompileOptions(version=5)
-teal6Options = CompileOptions(version=6)
+options = pt.CompileOptions()
+teal4Options = pt.CompileOptions(version=4)
+teal5Options = pt.CompileOptions(version=5)
+teal6Options = pt.CompileOptions(version=6)
 
 
 def test_acct_param_balance_valid():
-    arg = Int(1)
-    expr = AccountParam.balance(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.AccountParam.balance(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.acct_params_get, "AcctBalance"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.acct_params_get, "AcctBalance"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal6Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_acct_param_min_balance_valid():
-    arg = Int(0)
-    expr = AccountParam.minBalance(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(0)
+    expr = pt.AccountParam.minBalance(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.acct_params_get, "AcctMinBalance"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.acct_params_get, "AcctMinBalance"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal6Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_acct_param_auth_addr_valid():
-    arg = Int(1)
-    expr = AccountParam.authAddr(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(1)
+    expr = pt.AccountParam.authAddr(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.acct_params_get, "AcctAuthAddr"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.acct_params_get, "AcctAuthAddr"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal6Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
diff --git a/pyteal/ast/addr_test.py b/pyteal/ast/addr_test.py
index 66d8b302f..9187d69c2 100644
--- a/pyteal/ast/addr_test.py
+++ b/pyteal/ast/addr_test.py
@@ -1,30 +1,30 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
 
 def test_addr():
-    expr = Addr("NJUWK3DJNZTWU2LFNRUW4Z3KNFSWY2LOM5VGSZLMNFXGO2TJMVWGS3THMF")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock(
+    expr = pt.Addr("NJUWK3DJNZTWU2LFNRUW4Z3KNFSWY2LOM5VGSZLMNFXGO2TJMVWGS3THMF")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(
+            pt.TealOp(
                 expr,
-                Op.addr,
+                pt.Op.addr,
                 "NJUWK3DJNZTWU2LFNRUW4Z3KNFSWY2LOM5VGSZLMNFXGO2TJMVWGS3THMF",
             )
         ]
     )
-    actual, _ = expr.__teal__(CompileOptions())
+    actual, _ = expr.__teal__(pt.CompileOptions())
     assert actual == expected
 
 
 def test_addr_invalid():
-    with pytest.raises(TealInputError):
-        Addr("NJUWK3DJNZTWU2LFNRUW4Z3KNFSWY2LOM5VGSZLMNFXGO2TJMVWGS3TH")
+    with pytest.raises(pt.TealInputError):
+        pt.Addr("NJUWK3DJNZTWU2LFNRUW4Z3KNFSWY2LOM5VGSZLMNFXGO2TJMVWGS3TH")
 
-    with pytest.raises(TealInputError):
-        Addr("000000000000000000000000000000000000000000000000000000000")
+    with pytest.raises(pt.TealInputError):
+        pt.Addr("000000000000000000000000000000000000000000000000000000000")
 
-    with pytest.raises(TealInputError):
-        Addr(2)
+    with pytest.raises(pt.TealInputError):
+        pt.Addr(2)
diff --git a/pyteal/ast/app_test.py b/pyteal/ast/app_test.py
index 95f6b4ac2..5d16ab876 100644
--- a/pyteal/ast/app_test.py
+++ b/pyteal/ast/app_test.py
@@ -1,679 +1,676 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
-teal4Options = CompileOptions(version=4)
-teal5Options = CompileOptions(version=5)
+options = pt.CompileOptions()
+teal4Options = pt.CompileOptions(version=4)
+teal5Options = pt.CompileOptions(version=5)
 
 
 def test_on_complete():
-    assert OnComplete.NoOp.__teal__(options)[0] == TealSimpleBlock(
-        [TealOp(OnComplete.NoOp, Op.int, "NoOp")]
+    assert pt.OnComplete.NoOp.__teal__(options)[0] == pt.TealSimpleBlock(
+        [pt.TealOp(pt.OnComplete.NoOp, pt.Op.int, "NoOp")]
     )
 
-    assert OnComplete.OptIn.__teal__(options)[0] == TealSimpleBlock(
-        [TealOp(OnComplete.OptIn, Op.int, "OptIn")]
+    assert pt.OnComplete.OptIn.__teal__(options)[0] == pt.TealSimpleBlock(
+        [pt.TealOp(pt.OnComplete.OptIn, pt.Op.int, "OptIn")]
     )
 
-    assert OnComplete.CloseOut.__teal__(options)[0] == TealSimpleBlock(
-        [TealOp(OnComplete.CloseOut, Op.int, "CloseOut")]
+    assert pt.OnComplete.CloseOut.__teal__(options)[0] == pt.TealSimpleBlock(
+        [pt.TealOp(pt.OnComplete.CloseOut, pt.Op.int, "CloseOut")]
     )
 
-    assert OnComplete.ClearState.__teal__(options)[0] == TealSimpleBlock(
-        [TealOp(OnComplete.ClearState, Op.int, "ClearState")]
+    assert pt.OnComplete.ClearState.__teal__(options)[0] == pt.TealSimpleBlock(
+        [pt.TealOp(pt.OnComplete.ClearState, pt.Op.int, "ClearState")]
     )
 
-    assert OnComplete.UpdateApplication.__teal__(options)[0] == TealSimpleBlock(
-        [TealOp(OnComplete.UpdateApplication, Op.int, "UpdateApplication")]
+    assert pt.OnComplete.UpdateApplication.__teal__(options)[0] == pt.TealSimpleBlock(
+        [pt.TealOp(pt.OnComplete.UpdateApplication, pt.Op.int, "UpdateApplication")]
     )
 
-    assert OnComplete.DeleteApplication.__teal__(options)[0] == TealSimpleBlock(
-        [TealOp(OnComplete.DeleteApplication, Op.int, "DeleteApplication")]
+    assert pt.OnComplete.DeleteApplication.__teal__(options)[0] == pt.TealSimpleBlock(
+        [pt.TealOp(pt.OnComplete.DeleteApplication, pt.Op.int, "DeleteApplication")]
     )
 
 
 def test_app_id():
-    expr = App.id()
-    assert expr.type_of() == TealType.uint64
-    with TealComponent.Context.ignoreExprEquality():
+    expr = pt.App.id()
+    assert expr.type_of() == pt.TealType.uint64
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert (
             expr.__teal__(options)[0]
-            == Global.current_application_id().__teal__(options)[0]
+            == pt.Global.current_application_id().__teal__(options)[0]
         )
 
 
 def test_opted_in():
-    args = [Int(1), Int(12)]
-    expr = App.optedIn(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(1), pt.Int(12)]
+    expr = pt.App.optedIn(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 12),
-            TealOp(expr, Op.app_opted_in),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 12),
+            pt.TealOp(expr, pt.Op.app_opted_in),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_opted_in_direct_ref():
-    args = [Bytes("sender address"), Int(100)]
-    expr = App.optedIn(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Bytes("sender address"), pt.Int(100)]
+    expr = pt.App.optedIn(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"sender address"'),
-            TealOp(args[1], Op.int, 100),
-            TealOp(expr, Op.app_opted_in),
+            pt.TealOp(args[0], pt.Op.byte, '"sender address"'),
+            pt.TealOp(args[1], pt.Op.int, 100),
+            pt.TealOp(expr, pt.Op.app_opted_in),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_opted_in_invalid():
-    with pytest.raises(TealTypeError):
-        App.optedIn(Bytes("sender"), Bytes("100"))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.optedIn(pt.Bytes("sender"), pt.Bytes("100"))
 
-    with pytest.raises(TealTypeError):
-        App.optedIn(Int(123456), Bytes("364"))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.optedIn(pt.Int(123456), pt.Bytes("364"))
 
 
 def test_local_get():
-    args = [Int(0), Bytes("key")]
-    expr = App.localGet(args[0], args[1])
-    assert expr.type_of() == TealType.anytype
+    args = [pt.Int(0), pt.Bytes("key")]
+    expr = pt.App.localGet(args[0], args[1])
+    assert expr.type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 0),
-            TealOp(args[1], Op.byte, '"key"'),
-            TealOp(expr, Op.app_local_get),
+            pt.TealOp(args[0], pt.Op.int, 0),
+            pt.TealOp(args[1], pt.Op.byte, '"key"'),
+            pt.TealOp(expr, pt.Op.app_local_get),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_local_get_direct_ref():
-    args = [Txn.sender(), Bytes("key")]
-    expr = App.localGet(args[0], args[1])
-    assert expr.type_of() == TealType.anytype
+    args = [pt.Txn.sender(), pt.Bytes("key")]
+    expr = pt.App.localGet(args[0], args[1])
+    assert expr.type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.txn, "Sender"),
-            TealOp(args[1], Op.byte, '"key"'),
-            TealOp(expr, Op.app_local_get),
+            pt.TealOp(args[0], pt.Op.txn, "Sender"),
+            pt.TealOp(args[1], pt.Op.byte, '"key"'),
+            pt.TealOp(expr, pt.Op.app_local_get),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_local_get_invalid():
-    with pytest.raises(TealTypeError):
-        App.localGet(Txn.sender(), Int(1337))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.localGet(pt.Txn.sender(), pt.Int(1337))
 
-    with pytest.raises(TealTypeError):
-        App.localGet(Int(0), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.localGet(pt.Int(0), pt.Int(1))
 
 
 def test_local_get_ex():
-    args = [Int(0), Int(6), Bytes("key")]
-    expr = App.localGetEx(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.anytype
+    args = [pt.Int(0), pt.Int(6), pt.Bytes("key")]
+    expr = pt.App.localGetEx(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 0),
-            TealOp(args[1], Op.int, 6),
-            TealOp(args[2], Op.byte, '"key"'),
-            TealOp(expr, Op.app_local_get_ex),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(args[0], pt.Op.int, 0),
+            pt.TealOp(args[1], pt.Op.int, 6),
+            pt.TealOp(args[2], pt.Op.byte, '"key"'),
+            pt.TealOp(expr, pt.Op.app_local_get_ex),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_local_get_ex_direct_ref():
-    args = [Txn.sender(), Int(6), Bytes("key")]
-    expr = App.localGetEx(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.anytype
+    args = [pt.Txn.sender(), pt.Int(6), pt.Bytes("key")]
+    expr = pt.App.localGetEx(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.txn, "Sender"),
-            TealOp(args[1], Op.int, 6),
-            TealOp(args[2], Op.byte, '"key"'),
-            TealOp(expr, Op.app_local_get_ex),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(args[0], pt.Op.txn, "Sender"),
+            pt.TealOp(args[1], pt.Op.int, 6),
+            pt.TealOp(args[2], pt.Op.byte, '"key"'),
+            pt.TealOp(expr, pt.Op.app_local_get_ex),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_local_get_ex_invalid():
-    with pytest.raises(TealTypeError):
-        App.localGetEx(Txn.sender(), Int(0), Int(0x123456))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.localGetEx(pt.Txn.sender(), pt.Int(0), pt.Int(0x123456))
 
-    with pytest.raises(TealTypeError):
-        App.localGetEx(Int(0), Bytes("app"), Bytes("key"))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.localGetEx(pt.Int(0), pt.Bytes("app"), pt.Bytes("key"))
 
 
 def test_global_get():
-    arg = Bytes("key")
-    expr = App.globalGet(arg)
-    assert expr.type_of() == TealType.anytype
+    arg = pt.Bytes("key")
+    expr = pt.App.globalGet(arg)
+    assert expr.type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock(
-        [TealOp(arg, Op.byte, '"key"'), TealOp(expr, Op.app_global_get)]
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.byte, '"key"'), pt.TealOp(expr, pt.Op.app_global_get)]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_global_get_invalid():
-    with pytest.raises(TealTypeError):
-        App.globalGet(Int(7))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.globalGet(pt.Int(7))
 
 
 def test_global_get_ex():
-    args = [Int(6), Bytes("key")]
-    expr = App.globalGetEx(args[0], args[1])
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.anytype
+    args = [pt.Int(6), pt.Bytes("key")]
+    expr = pt.App.globalGetEx(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 6),
-            TealOp(args[1], Op.byte, '"key"'),
-            TealOp(expr, Op.app_global_get_ex),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(args[0], pt.Op.int, 6),
+            pt.TealOp(args[1], pt.Op.byte, '"key"'),
+            pt.TealOp(expr, pt.Op.app_global_get_ex),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_global_get_ex_direct_ref():
-    args = [Txn.applications[0], Bytes("key")]
-    expr = App.globalGetEx(args[0], args[1])
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.anytype
+    args = [pt.Txn.applications[0], pt.Bytes("key")]
+    expr = pt.App.globalGetEx(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.txna, "Applications", 0),
-            TealOp(args[1], Op.byte, '"key"'),
-            TealOp(expr, Op.app_global_get_ex),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(args[0], pt.Op.txna, "Applications", 0),
+            pt.TealOp(args[1], pt.Op.byte, '"key"'),
+            pt.TealOp(expr, pt.Op.app_global_get_ex),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_global_get_ex_invalid():
-    with pytest.raises(TealTypeError):
-        App.globalGetEx(Bytes("app"), Int(12))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.globalGetEx(pt.Bytes("app"), pt.Int(12))
 
-    with pytest.raises(TealTypeError):
-        App.globalGetEx(Int(0), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.globalGetEx(pt.Int(0), pt.Int(1))
 
 
 def test_local_put():
-    args = [Int(0), Bytes("key"), Int(5)]
-    expr = App.localPut(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.none
+    args = [pt.Int(0), pt.Bytes("key"), pt.Int(5)]
+    expr = pt.App.localPut(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.none
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 0),
-            TealOp(args[1], Op.byte, '"key"'),
-            TealOp(args[2], Op.int, 5),
-            TealOp(expr, Op.app_local_put),
+            pt.TealOp(args[0], pt.Op.int, 0),
+            pt.TealOp(args[1], pt.Op.byte, '"key"'),
+            pt.TealOp(args[2], pt.Op.int, 5),
+            pt.TealOp(expr, pt.Op.app_local_put),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_local_put_direct_ref():
-    args = [Txn.sender(), Bytes("key"), Int(5)]
-    expr = App.localPut(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.none
+    args = [pt.Txn.sender(), pt.Bytes("key"), pt.Int(5)]
+    expr = pt.App.localPut(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.none
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.txn, "Sender"),
-            TealOp(args[1], Op.byte, '"key"'),
-            TealOp(args[2], Op.int, 5),
-            TealOp(expr, Op.app_local_put),
+            pt.TealOp(args[0], pt.Op.txn, "Sender"),
+            pt.TealOp(args[1], pt.Op.byte, '"key"'),
+            pt.TealOp(args[2], pt.Op.int, 5),
+            pt.TealOp(expr, pt.Op.app_local_put),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_local_put_invalid():
-    with pytest.raises(TealTypeError):
-        App.localPut(Txn.sender(), Int(55), Int(5))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.localPut(pt.Txn.sender(), pt.Int(55), pt.Int(5))
 
-    with pytest.raises(TealTypeError):
-        App.localPut(Int(1), Int(0), Int(5))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.localPut(pt.Int(1), pt.Int(0), pt.Int(5))
 
-    with pytest.raises(TealTypeError):
-        App.localPut(Int(1), Bytes("key"), Pop(Int(1)))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.localPut(pt.Int(1), pt.Bytes("key"), pt.Pop(pt.Int(1)))
 
 
 def test_global_put():
-    args = [Bytes("key"), Int(5)]
-    expr = App.globalPut(args[0], args[1])
-    assert expr.type_of() == TealType.none
+    args = [pt.Bytes("key"), pt.Int(5)]
+    expr = pt.App.globalPut(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"key"'),
-            TealOp(args[1], Op.int, 5),
-            TealOp(expr, Op.app_global_put),
+            pt.TealOp(args[0], pt.Op.byte, '"key"'),
+            pt.TealOp(args[1], pt.Op.int, 5),
+            pt.TealOp(expr, pt.Op.app_global_put),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_global_put_invalid():
-    with pytest.raises(TealTypeError):
-        App.globalPut(Int(0), Int(5))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.globalPut(pt.Int(0), pt.Int(5))
 
-    with pytest.raises(TealTypeError):
-        App.globalPut(Bytes("key"), Pop(Int(1)))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.globalPut(pt.Bytes("key"), pt.Pop(pt.Int(1)))
 
 
 def test_local_del():
-    args = [Int(0), Bytes("key")]
-    expr = App.localDel(args[0], args[1])
-    assert expr.type_of() == TealType.none
+    args = [pt.Int(0), pt.Bytes("key")]
+    expr = pt.App.localDel(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 0),
-            TealOp(args[1], Op.byte, '"key"'),
-            TealOp(expr, Op.app_local_del),
+            pt.TealOp(args[0], pt.Op.int, 0),
+            pt.TealOp(args[1], pt.Op.byte, '"key"'),
+            pt.TealOp(expr, pt.Op.app_local_del),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_local_del_direct_ref():
-    args = [Txn.sender(), Bytes("key")]
-    expr = App.localDel(args[0], args[1])
-    assert expr.type_of() == TealType.none
+    args = [pt.Txn.sender(), pt.Bytes("key")]
+    expr = pt.App.localDel(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.txn, "Sender"),
-            TealOp(args[1], Op.byte, '"key"'),
-            TealOp(expr, Op.app_local_del),
+            pt.TealOp(args[0], pt.Op.txn, "Sender"),
+            pt.TealOp(args[1], pt.Op.byte, '"key"'),
+            pt.TealOp(expr, pt.Op.app_local_del),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_local_del_invalid():
-    with pytest.raises(TealTypeError):
-        App.localDel(Txn.sender(), Int(123))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.localDel(pt.Txn.sender(), pt.Int(123))
 
-    with pytest.raises(TealTypeError):
-        App.localDel(Int(1), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.localDel(pt.Int(1), pt.Int(2))
 
 
 def test_global_del():
-    arg = Bytes("key")
-    expr = App.globalDel(arg)
-    assert expr.type_of() == TealType.none
+    arg = pt.Bytes("key")
+    expr = pt.App.globalDel(arg)
+    assert expr.type_of() == pt.TealType.none
 
-    expected = TealSimpleBlock(
-        [TealOp(arg, Op.byte, '"key"'), TealOp(expr, Op.app_global_del)]
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.byte, '"key"'), pt.TealOp(expr, pt.Op.app_global_del)]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_global_del_invalid():
-    with pytest.raises(TealTypeError):
-        App.globalDel(Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.App.globalDel(pt.Int(2))
 
 
 def test_app_param_approval_program_valid():
-    arg = Int(1)
-    expr = AppParam.approvalProgram(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(1)
+    expr = pt.AppParam.approvalProgram(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.app_params_get, "AppApprovalProgram"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.app_params_get, "AppApprovalProgram"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_app_param_approval_program_invalid():
-    with pytest.raises(TealTypeError):
-        AppParam.approvalProgram(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AppParam.approvalProgram(pt.Txn.sender())
 
 
 def test_app_param_clear_state_program_valid():
-    arg = Int(0)
-    expr = AppParam.clearStateProgram(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(0)
+    expr = pt.AppParam.clearStateProgram(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.app_params_get, "AppClearStateProgram"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.app_params_get, "AppClearStateProgram"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_app_param_clear_state_program_invalid():
-    with pytest.raises(TealTypeError):
-        AppParam.clearStateProgram(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AppParam.clearStateProgram(pt.Txn.sender())
 
 
 def test_app_param_global_num_unit_valid():
-    arg = Int(1)
-    expr = AppParam.globalNumUnit(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.AppParam.globalNumUnit(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.app_params_get, "AppGlobalNumUnit"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.app_params_get, "AppGlobalNumUnit"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_app_param_global_num_unit_invalid():
-    with pytest.raises(TealTypeError):
-        AppParam.globalNumUnit(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AppParam.globalNumUnit(pt.Txn.sender())
 
 
 def test_app_param_global_num_byte_slice_valid():
-    arg = Int(1)
-    expr = AppParam.globalNumByteSlice(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.AppParam.globalNumByteSlice(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.app_params_get, "AppGlobalNumByteSlice"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.app_params_get, "AppGlobalNumByteSlice"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_app_param_global_num_byte_slice_invalid():
-    with pytest.raises(TealTypeError):
-        AppParam.globalNumByteSlice(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AppParam.globalNumByteSlice(pt.Txn.sender())
 
 
 def test_app_param_local_num_unit_valid():
-    arg = Int(1)
-    expr = AppParam.localNumUnit(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.AppParam.localNumUnit(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.app_params_get, "AppLocalNumUnit"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.app_params_get, "AppLocalNumUnit"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_app_param_local_num_unit_invalid():
-    with pytest.raises(TealTypeError):
-        AppParam.localNumUnit(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AppParam.localNumUnit(pt.Txn.sender())
 
 
 def test_app_param_local_num_byte_slice_valid():
-    arg = Int(1)
-    expr = AppParam.localNumByteSlice(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.AppParam.localNumByteSlice(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.app_params_get, "AppLocalNumByteSlice"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.app_params_get, "AppLocalNumByteSlice"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_app_param_local_num_byte_slice_invalid():
-    with pytest.raises(TealTypeError):
-        AppParam.localNumByteSlice(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AppParam.localNumByteSlice(pt.Txn.sender())
 
 
 def test_app_param_extra_programs_page_valid():
-    arg = Int(1)
-    expr = AppParam.extraProgramPages(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.AppParam.extraProgramPages(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.app_params_get, "AppExtraProgramPages"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.app_params_get, "AppExtraProgramPages"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_app_param_extra_program_pages_invalid():
-    with pytest.raises(TealTypeError):
-        AppParam.extraProgramPages(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AppParam.extraProgramPages(pt.Txn.sender())
 
 
 def test_app_param_creator_valid():
-    arg = Int(1)
-    expr = AppParam.creator(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(1)
+    expr = pt.AppParam.creator(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.app_params_get, "AppCreator"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.app_params_get, "AppCreator"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_app_param_creator_invalid():
-    with pytest.raises(TealTypeError):
-        AppParam.creator(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AppParam.creator(pt.Txn.sender())
 
 
 def test_app_param_address_valid():
-    arg = Int(1)
-    expr = AppParam.address(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(1)
+    expr = pt.AppParam.address(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.app_params_get, "AppAddress"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.app_params_get, "AppAddress"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_app_param_address_invalid():
-    with pytest.raises(TealTypeError):
-        AppParam.address(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AppParam.address(pt.Txn.sender())
diff --git a/pyteal/ast/arg_test.py b/pyteal/ast/arg_test.py
index 7d622ddb7..90cfc8929 100644
--- a/pyteal/ast/arg_test.py
+++ b/pyteal/ast/arg_test.py
@@ -1,51 +1,50 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-teal2Options = CompileOptions(version=2)
-teal4Options = CompileOptions(version=4)
-teal5Options = CompileOptions(version=5)
+teal2Options = pt.CompileOptions(version=2)
+teal4Options = pt.CompileOptions(version=4)
+teal5Options = pt.CompileOptions(version=5)
 
 
 def test_arg_static():
     for i in range(256):
-        expr = Arg(i)
-        assert expr.type_of() == TealType.bytes
+        expr = pt.Arg(i)
+        assert expr.type_of() == pt.TealType.bytes
         assert not expr.has_return()
 
-        expected = TealSimpleBlock([TealOp(expr, Op.arg, i)])
+        expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.arg, i)])
 
         actual, _ = expr.__teal__(teal2Options)
         assert actual == expected
 
 
 def test_arg_dynamic():
-    i = Int(7)
-    expr = Arg(i)
-    assert expr.type_of() == TealType.bytes
+    i = pt.Int(7)
+    expr = pt.Arg(i)
+    assert expr.type_of() == pt.TealType.bytes
     assert not expr.has_return()
 
-    expected = TealSimpleBlock([TealOp(i, Op.int, 7), TealOp(expr, Op.args)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(i, pt.Op.int, 7), pt.TealOp(expr, pt.Op.args)]
+    )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal4Options)
 
 
 def test_arg_invalid():
-    with pytest.raises(TealTypeError):
-        Arg(Bytes("k"))
+    with pytest.raises(pt.TealTypeError):
+        pt.Arg(pt.Bytes("k"))
 
-    with pytest.raises(TealInputError):
-        Arg(-1)
+    with pytest.raises(pt.TealInputError):
+        pt.Arg(-1)
 
-    with pytest.raises(TealInputError):
-        Arg(256)
+    with pytest.raises(pt.TealInputError):
+        pt.Arg(256)
diff --git a/pyteal/ast/assert_test.py b/pyteal/ast/assert_test.py
index dbce8bbd9..fd6b756ab 100644
--- a/pyteal/ast/assert_test.py
+++ b/pyteal/ast/assert_test.py
@@ -1,45 +1,44 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-teal2Options = CompileOptions(version=2)
-teal3Options = CompileOptions(version=3)
+teal2Options = pt.CompileOptions(version=2)
+teal3Options = pt.CompileOptions(version=3)
 
 
 def test_teal_2_assert():
-    arg = Int(1)
-    expr = Assert(arg)
-    assert expr.type_of() == TealType.none
+    arg = pt.Int(1)
+    expr = pt.Assert(arg)
+    assert expr.type_of() == pt.TealType.none
 
     expected, _ = arg.__teal__(teal2Options)
-    expectedBranch = TealConditionalBlock([])
-    expectedBranch.setTrueBlock(TealSimpleBlock([]))
-    expectedBranch.setFalseBlock(Err().__teal__(teal2Options)[0])
+    expectedBranch = pt.TealConditionalBlock([])
+    expectedBranch.setTrueBlock(pt.TealSimpleBlock([]))
+    expectedBranch.setFalseBlock(pt.Err().__teal__(teal2Options)[0])
     expected.setNextBlock(expectedBranch)
 
     actual, _ = expr.__teal__(teal2Options)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_teal_3_assert():
-    arg = Int(1)
-    expr = Assert(arg)
-    assert expr.type_of() == TealType.none
+    arg = pt.Int(1)
+    expr = pt.Assert(arg)
+    assert expr.type_of() == pt.TealType.none
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 1), TealOp(expr, Op.assert_)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 1), pt.TealOp(expr, pt.Op.assert_)]
+    )
 
     actual, _ = expr.__teal__(teal3Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_assert_invalid():
-    with pytest.raises(TealTypeError):
-        Assert(Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Assert(pt.Txn.receiver())
diff --git a/pyteal/ast/asset_test.py b/pyteal/ast/asset_test.py
index c51b8833a..6ac9cf0e1 100644
--- a/pyteal/ast/asset_test.py
+++ b/pyteal/ast/asset_test.py
@@ -1,711 +1,708 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-teal2Options = CompileOptions()
-teal4Options = CompileOptions(version=4)
-teal5Options = CompileOptions(version=5)
+teal2Options = pt.CompileOptions()
+teal4Options = pt.CompileOptions(version=4)
+teal5Options = pt.CompileOptions(version=5)
 
 
 def test_asset_holding_balance():
-    args = Int(0), Int(17)
-    expr = AssetHolding.balance(args[0], args[1])
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    args = pt.Int(0), pt.Int(17)
+    expr = pt.AssetHolding.balance(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 0),
-            TealOp(args[1], Op.int, 17),
-            TealOp(expr, Op.asset_holding_get, "AssetBalance"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(args[0], pt.Op.int, 0),
+            pt.TealOp(args[1], pt.Op.int, 17),
+            pt.TealOp(expr, pt.Op.asset_holding_get, "AssetBalance"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_holding_balance_direct_ref():
-    args = [Txn.sender(), Txn.assets[17]]
-    expr = AssetHolding.balance(args[0], args[1])
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    args = [pt.Txn.sender(), pt.Txn.assets[17]]
+    expr = pt.AssetHolding.balance(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.txn, "Sender"),
-            TealOp(args[1], Op.txna, "Assets", 17),
-            TealOp(expr, Op.asset_holding_get, "AssetBalance"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(args[0], pt.Op.txn, "Sender"),
+            pt.TealOp(args[1], pt.Op.txna, "Assets", 17),
+            pt.TealOp(expr, pt.Op.asset_holding_get, "AssetBalance"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_holding_balance_invalid():
-    with pytest.raises(TealTypeError):
-        AssetHolding.balance(Txn.sender(), Bytes("100"))
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetHolding.balance(pt.Txn.sender(), pt.Bytes("100"))
 
-    with pytest.raises(TealTypeError):
-        AssetHolding.balance(Int(0), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetHolding.balance(pt.Int(0), pt.Txn.receiver())
 
 
 def test_asset_holding_frozen():
-    args = [Int(0), Int(17)]
-    expr = AssetHolding.frozen(args[0], args[1])
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    args = [pt.Int(0), pt.Int(17)]
+    expr = pt.AssetHolding.frozen(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 0),
-            TealOp(args[1], Op.int, 17),
-            TealOp(expr, Op.asset_holding_get, "AssetFrozen"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(args[0], pt.Op.int, 0),
+            pt.TealOp(args[1], pt.Op.int, 17),
+            pt.TealOp(expr, pt.Op.asset_holding_get, "AssetFrozen"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_holding_frozen_direct_ref():
-    args = [Txn.sender(), Txn.assets[17]]
-    expr = AssetHolding.frozen(args[0], args[1])
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    args = [pt.Txn.sender(), pt.Txn.assets[17]]
+    expr = pt.AssetHolding.frozen(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.txn, "Sender"),
-            TealOp(args[1], Op.txna, "Assets", 17),
-            TealOp(expr, Op.asset_holding_get, "AssetFrozen"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(args[0], pt.Op.txn, "Sender"),
+            pt.TealOp(args[1], pt.Op.txna, "Assets", 17),
+            pt.TealOp(expr, pt.Op.asset_holding_get, "AssetFrozen"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_holding_frozen_invalid():
-    with pytest.raises(TealTypeError):
-        AssetHolding.frozen(Txn.sender(), Bytes("17"))
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetHolding.frozen(pt.Txn.sender(), pt.Bytes("17"))
 
-    with pytest.raises(TealTypeError):
-        AssetHolding.frozen(Int(0), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetHolding.frozen(pt.Int(0), pt.Txn.receiver())
 
 
 def test_asset_param_total():
-    arg = Int(0)
-    expr = AssetParam.total(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(0)
+    expr = pt.AssetParam.total(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.asset_params_get, "AssetTotal"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetTotal"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_total_direct_ref():
-    arg = Txn.assets[0]
-    expr = AssetParam.total(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Txn.assets[0]
+    expr = pt.AssetParam.total(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 0),
-            TealOp(expr, Op.asset_params_get, "AssetTotal"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetTotal"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_total_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.total(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.total(pt.Txn.sender())
 
 
 def test_asset_param_decimals():
-    arg = Int(0)
-    expr = AssetParam.decimals(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(0)
+    expr = pt.AssetParam.decimals(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.asset_params_get, "AssetDecimals"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetDecimals"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_decimals_direct_ref():
-    arg = Txn.assets[0]
-    expr = AssetParam.decimals(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Txn.assets[0]
+    expr = pt.AssetParam.decimals(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 0),
-            TealOp(expr, Op.asset_params_get, "AssetDecimals"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetDecimals"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_decimals_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.decimals(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.decimals(pt.Txn.sender())
 
 
 def test_asset_param_default_frozen():
-    arg = Int(0)
-    expr = AssetParam.defaultFrozen(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Int(0)
+    expr = pt.AssetParam.defaultFrozen(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.asset_params_get, "AssetDefaultFrozen"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetDefaultFrozen"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_default_frozen_direct_ref():
-    arg = Txn.assets[0]
-    expr = AssetParam.defaultFrozen(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.uint64
+    arg = pt.Txn.assets[0]
+    expr = pt.AssetParam.defaultFrozen(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 0),
-            TealOp(expr, Op.asset_params_get, "AssetDefaultFrozen"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetDefaultFrozen"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_default_frozen_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.defaultFrozen(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.defaultFrozen(pt.Txn.sender())
 
 
 def test_asset_param_unit_name():
-    arg = Int(0)
-    expr = AssetParam.unitName(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(0)
+    expr = pt.AssetParam.unitName(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.asset_params_get, "AssetUnitName"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetUnitName"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_unit_name_direct_ref():
-    arg = Txn.assets[0]
-    expr = AssetParam.unitName(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Txn.assets[0]
+    expr = pt.AssetParam.unitName(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 0),
-            TealOp(expr, Op.asset_params_get, "AssetUnitName"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetUnitName"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_unit_name_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.unitName(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.unitName(pt.Txn.sender())
 
 
 def test_asset_param_name():
-    arg = Int(0)
-    expr = AssetParam.name(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(0)
+    expr = pt.AssetParam.name(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.asset_params_get, "AssetName"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetName"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_name_direct_ref():
-    arg = Txn.assets[0]
-    expr = AssetParam.name(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Txn.assets[0]
+    expr = pt.AssetParam.name(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 0),
-            TealOp(expr, Op.asset_params_get, "AssetName"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetName"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_name_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.name(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.name(pt.Txn.sender())
 
 
 def test_asset_param_url():
-    arg = Int(0)
-    expr = AssetParam.url(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(0)
+    expr = pt.AssetParam.url(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.asset_params_get, "AssetURL"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetURL"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_url_direct_ref():
-    arg = Txn.assets[0]
-    expr = AssetParam.url(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Txn.assets[0]
+    expr = pt.AssetParam.url(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 0),
-            TealOp(expr, Op.asset_params_get, "AssetURL"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetURL"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_url_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.url(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.url(pt.Txn.sender())
 
 
 def test_asset_param_metadata_hash():
-    arg = Int(0)
-    expr = AssetParam.metadataHash(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(0)
+    expr = pt.AssetParam.metadataHash(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.asset_params_get, "AssetMetadataHash"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetMetadataHash"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_metadata_hash_direct_ref():
-    arg = Txn.assets[0]
-    expr = AssetParam.metadataHash(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Txn.assets[0]
+    expr = pt.AssetParam.metadataHash(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 0),
-            TealOp(expr, Op.asset_params_get, "AssetMetadataHash"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetMetadataHash"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_metadata_hash_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.metadataHash(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.metadataHash(pt.Txn.sender())
 
 
 def test_asset_param_manager():
-    arg = Int(0)
-    expr = AssetParam.manager(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(0)
+    expr = pt.AssetParam.manager(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.asset_params_get, "AssetManager"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetManager"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_manager_direct_ref():
-    arg = Txn.assets[0]
-    expr = AssetParam.manager(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Txn.assets[0]
+    expr = pt.AssetParam.manager(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 0),
-            TealOp(expr, Op.asset_params_get, "AssetManager"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetManager"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_manager_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.manager(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.manager(pt.Txn.sender())
 
 
 def test_asset_param_reserve():
-    arg = Int(2)
-    expr = AssetParam.reserve(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(2)
+    expr = pt.AssetParam.reserve(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 2),
-            TealOp(expr, Op.asset_params_get, "AssetReserve"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 2),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetReserve"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_reserve_direct_ref():
-    arg = Txn.assets[2]
-    expr = AssetParam.reserve(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Txn.assets[2]
+    expr = pt.AssetParam.reserve(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 2),
-            TealOp(expr, Op.asset_params_get, "AssetReserve"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 2),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetReserve"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_reserve_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.reserve(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.reserve(pt.Txn.sender())
 
 
 def test_asset_param_freeze():
-    arg = Int(0)
-    expr = AssetParam.freeze(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(0)
+    expr = pt.AssetParam.freeze(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 0),
-            TealOp(expr, Op.asset_params_get, "AssetFreeze"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetFreeze"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_freeze_direct_ref():
-    arg = Txn.assets[0]
-    expr = AssetParam.freeze(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Txn.assets[0]
+    expr = pt.AssetParam.freeze(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 0),
-            TealOp(expr, Op.asset_params_get, "AssetFreeze"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 0),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetFreeze"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_freeze_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.freeze(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.freeze(pt.Txn.sender())
 
 
 def test_asset_param_clawback():
-    arg = Int(1)
-    expr = AssetParam.clawback(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(1)
+    expr = pt.AssetParam.clawback(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.asset_params_get, "AssetClawback"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetClawback"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_clawback_direct_ref():
-    arg = Txn.assets[1]
-    expr = AssetParam.clawback(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Txn.assets[1]
+    expr = pt.AssetParam.clawback(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.txna, "Assets", 1),
-            TealOp(expr, Op.asset_params_get, "AssetClawback"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.txna, "Assets", 1),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetClawback"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_clawback_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.clawback(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.clawback(pt.Txn.sender())
 
 
 def test_asset_param_creator_valid():
-    arg = Int(1)
-    expr = AssetParam.creator(arg)
-    assert expr.type_of() == TealType.none
-    assert expr.value().type_of() == TealType.bytes
+    arg = pt.Int(1)
+    expr = pt.AssetParam.creator(arg)
+    assert expr.type_of() == pt.TealType.none
+    assert expr.value().type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 1),
-            TealOp(expr, Op.asset_params_get, "AssetCreator"),
-            TealOp(None, Op.store, expr.slotOk),
-            TealOp(None, Op.store, expr.slotValue),
+            pt.TealOp(arg, pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.asset_params_get, "AssetCreator"),
+            pt.TealOp(None, pt.Op.store, expr.slotOk),
+            pt.TealOp(None, pt.Op.store, expr.slotValue),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_asset_param_creator_invalid():
-    with pytest.raises(TealTypeError):
-        AssetParam.creator(Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.AssetParam.creator(pt.Txn.sender())
diff --git a/pyteal/ast/binaryexpr_test.py b/pyteal/ast/binaryexpr_test.py
index 9602be208..a1b493365 100644
--- a/pyteal/ast/binaryexpr_test.py
+++ b/pyteal/ast/binaryexpr_test.py
@@ -1,1499 +1,1560 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-teal2Options = CompileOptions(version=2)
-teal3Options = CompileOptions(version=3)
-teal4Options = CompileOptions(version=4)
-teal5Options = CompileOptions(version=5)
+teal2Options = pt.CompileOptions(version=2)
+teal3Options = pt.CompileOptions(version=3)
+teal4Options = pt.CompileOptions(version=4)
+teal5Options = pt.CompileOptions(version=5)
 
 
 def test_add():
-    args = [Int(2), Int(3)]
-    expr = Add(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(2), pt.Int(3)]
+    expr = pt.Add(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 2), TealOp(args[1], Op.int, 3), TealOp(expr, Op.add)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 2),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(expr, pt.Op.add),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_add_overload():
-    args = [Int(2), Int(3), Int(4)]
+    args = [pt.Int(2), pt.Int(3), pt.Int(4)]
     expr = args[0] + args[1] + args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 2),
-            TealOp(args[1], Op.int, 3),
-            TealOp(None, Op.add),
-            TealOp(args[2], Op.int, 4),
-            TealOp(None, Op.add),
+            pt.TealOp(args[0], pt.Op.int, 2),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.add),
+            pt.TealOp(args[2], pt.Op.int, 4),
+            pt.TealOp(None, pt.Op.add),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_add_invalid():
-    with pytest.raises(TealTypeError):
-        Add(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Add(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Add(Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Add(pt.Txn.sender(), pt.Int(2))
 
 
 def test_minus():
-    args = [Int(5), Int(6)]
-    expr = Minus(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(5), pt.Int(6)]
+    expr = pt.Minus(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 5), TealOp(args[1], Op.int, 6), TealOp(expr, Op.minus)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 5),
+            pt.TealOp(args[1], pt.Op.int, 6),
+            pt.TealOp(expr, pt.Op.minus),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_minus_overload():
-    args = [Int(10), Int(1), Int(2)]
+    args = [pt.Int(10), pt.Int(1), pt.Int(2)]
     expr = args[0] - args[1] - args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 10),
-            TealOp(args[1], Op.int, 1),
-            TealOp(None, Op.minus),
-            TealOp(args[2], Op.int, 2),
-            TealOp(None, Op.minus),
+            pt.TealOp(args[0], pt.Op.int, 10),
+            pt.TealOp(args[1], pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.minus),
+            pt.TealOp(args[2], pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.minus),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_minus_invalid():
-    with pytest.raises(TealTypeError):
-        Minus(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Minus(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Minus(Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Minus(pt.Txn.sender(), pt.Int(2))
 
 
 def test_mul():
-    args = [Int(3), Int(8)]
-    expr = Mul(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(3), pt.Int(8)]
+    expr = pt.Mul(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 3), TealOp(args[1], Op.int, 8), TealOp(expr, Op.mul)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 3),
+            pt.TealOp(args[1], pt.Op.int, 8),
+            pt.TealOp(expr, pt.Op.mul),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_mul_overload():
-    args = [Int(3), Int(8), Int(10)]
+    args = [pt.Int(3), pt.Int(8), pt.Int(10)]
     expr = args[0] * args[1] * args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 3),
-            TealOp(args[1], Op.int, 8),
-            TealOp(None, Op.mul),
-            TealOp(args[2], Op.int, 10),
-            TealOp(None, Op.mul),
+            pt.TealOp(args[0], pt.Op.int, 3),
+            pt.TealOp(args[1], pt.Op.int, 8),
+            pt.TealOp(None, pt.Op.mul),
+            pt.TealOp(args[2], pt.Op.int, 10),
+            pt.TealOp(None, pt.Op.mul),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_mul_invalid():
-    with pytest.raises(TealTypeError):
-        Mul(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Mul(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Mul(Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Mul(pt.Txn.sender(), pt.Int(2))
 
 
 def test_div():
-    args = [Int(9), Int(3)]
-    expr = Div(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(9), pt.Int(3)]
+    expr = pt.Div(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 9), TealOp(args[1], Op.int, 3), TealOp(expr, Op.div)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 9),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(expr, pt.Op.div),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_div_overload():
-    args = [Int(9), Int(3), Int(3)]
+    args = [pt.Int(9), pt.Int(3), pt.Int(3)]
     expr = args[0] / args[1] / args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 9),
-            TealOp(args[1], Op.int, 3),
-            TealOp(None, Op.div),
-            TealOp(args[2], Op.int, 3),
-            TealOp(None, Op.div),
+            pt.TealOp(args[0], pt.Op.int, 9),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.div),
+            pt.TealOp(args[2], pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.div),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_div_invalid():
-    with pytest.raises(TealTypeError):
-        Div(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Div(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Div(Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Div(pt.Txn.sender(), pt.Int(2))
 
 
 def test_mod():
-    args = [Int(10), Int(9)]
-    expr = Mod(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(10), pt.Int(9)]
+    expr = pt.Mod(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 10), TealOp(args[1], Op.int, 9), TealOp(expr, Op.mod)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 10),
+            pt.TealOp(args[1], pt.Op.int, 9),
+            pt.TealOp(expr, pt.Op.mod),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_mod_overload():
-    args = [Int(10), Int(9), Int(100)]
+    args = [pt.Int(10), pt.Int(9), pt.Int(100)]
     expr = args[0] % args[1] % args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 10),
-            TealOp(args[1], Op.int, 9),
-            TealOp(None, Op.mod),
-            TealOp(args[2], Op.int, 100),
-            TealOp(None, Op.mod),
+            pt.TealOp(args[0], pt.Op.int, 10),
+            pt.TealOp(args[1], pt.Op.int, 9),
+            pt.TealOp(None, pt.Op.mod),
+            pt.TealOp(args[2], pt.Op.int, 100),
+            pt.TealOp(None, pt.Op.mod),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_mod_invalid():
-    with pytest.raises(TealTypeError):
-        Mod(Txn.receiver(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Mod(pt.Txn.receiver(), pt.Int(2))
 
-    with pytest.raises(TealTypeError):
-        Mod(Int(2), Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.Mod(pt.Int(2), pt.Txn.sender())
 
 
 def test_exp():
-    args = [Int(2), Int(9)]
-    expr = Exp(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(2), pt.Int(9)]
+    expr = pt.Exp(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 2), TealOp(args[1], Op.int, 9), TealOp(expr, Op.exp)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 2),
+            pt.TealOp(args[1], pt.Op.int, 9),
+            pt.TealOp(expr, pt.Op.exp),
+        ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_exp_overload():
-    args = [Int(2), Int(3), Int(1)]
+    args = [pt.Int(2), pt.Int(3), pt.Int(1)]
     # this is equivalent to args[0] ** (args[1] ** args[2])
     expr = args[0] ** args[1] ** args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 2),
-            TealOp(args[1], Op.int, 3),
-            TealOp(args[2], Op.int, 1),
-            TealOp(None, Op.exp),
-            TealOp(None, Op.exp),
+            pt.TealOp(args[0], pt.Op.int, 2),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(args[2], pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.exp),
+            pt.TealOp(None, pt.Op.exp),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_exp_invalid():
-    with pytest.raises(TealTypeError):
-        Exp(Txn.receiver(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Exp(pt.Txn.receiver(), pt.Int(2))
 
-    with pytest.raises(TealTypeError):
-        Exp(Int(2), Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.Exp(pt.Int(2), pt.Txn.sender())
 
 
 def test_arithmetic():
-    args = [Int(2), Int(3), Int(5), Int(6), Int(8), Int(9)]
+    args = [pt.Int(2), pt.Int(3), pt.Int(5), pt.Int(6), pt.Int(8), pt.Int(9)]
     v = ((args[0] + args[1]) / ((args[2] - args[3]) * args[4])) % args[5]
-    assert v.type_of() == TealType.uint64
+    assert v.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 2),
-            TealOp(args[1], Op.int, 3),
-            TealOp(None, Op.add),
-            TealOp(args[2], Op.int, 5),
-            TealOp(args[3], Op.int, 6),
-            TealOp(None, Op.minus),
-            TealOp(args[4], Op.int, 8),
-            TealOp(None, Op.mul),
-            TealOp(None, Op.div),
-            TealOp(args[5], Op.int, 9),
-            TealOp(None, Op.mod),
+            pt.TealOp(args[0], pt.Op.int, 2),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.add),
+            pt.TealOp(args[2], pt.Op.int, 5),
+            pt.TealOp(args[3], pt.Op.int, 6),
+            pt.TealOp(None, pt.Op.minus),
+            pt.TealOp(args[4], pt.Op.int, 8),
+            pt.TealOp(None, pt.Op.mul),
+            pt.TealOp(None, pt.Op.div),
+            pt.TealOp(args[5], pt.Op.int, 9),
+            pt.TealOp(None, pt.Op.mod),
         ]
     )
 
     actual, _ = v.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_bitwise_and():
-    args = [Int(1), Int(2)]
-    expr = BitwiseAnd(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(1), pt.Int(2)]
+    expr = pt.BitwiseAnd(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 2),
-            TealOp(expr, Op.bitwise_and),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(expr, pt.Op.bitwise_and),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_bitwise_and_overload():
-    args = [Int(1), Int(2), Int(4)]
+    args = [pt.Int(1), pt.Int(2), pt.Int(4)]
     expr = args[0] & args[1] & args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 2),
-            TealOp(None, Op.bitwise_and),
-            TealOp(args[2], Op.int, 4),
-            TealOp(None, Op.bitwise_and),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.bitwise_and),
+            pt.TealOp(args[2], pt.Op.int, 4),
+            pt.TealOp(None, pt.Op.bitwise_and),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_bitwise_and_invalid():
-    with pytest.raises(TealTypeError):
-        BitwiseAnd(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BitwiseAnd(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BitwiseAnd(Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BitwiseAnd(pt.Txn.sender(), pt.Int(2))
 
 
 def test_bitwise_or():
-    args = [Int(1), Int(2)]
-    expr = BitwiseOr(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(1), pt.Int(2)]
+    expr = pt.BitwiseOr(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 2),
-            TealOp(expr, Op.bitwise_or),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(expr, pt.Op.bitwise_or),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_bitwise_or_overload():
-    args = [Int(1), Int(2), Int(4)]
+    args = [pt.Int(1), pt.Int(2), pt.Int(4)]
     expr = args[0] | args[1] | args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 2),
-            TealOp(None, Op.bitwise_or),
-            TealOp(args[2], Op.int, 4),
-            TealOp(None, Op.bitwise_or),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.bitwise_or),
+            pt.TealOp(args[2], pt.Op.int, 4),
+            pt.TealOp(None, pt.Op.bitwise_or),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_bitwise_or_invalid():
-    with pytest.raises(TealTypeError):
-        BitwiseOr(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BitwiseOr(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BitwiseOr(Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BitwiseOr(pt.Txn.sender(), pt.Int(2))
 
 
 def test_bitwise_xor():
-    args = [Int(1), Int(3)]
-    expr = BitwiseXor(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(1), pt.Int(3)]
+    expr = pt.BitwiseXor(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 3),
-            TealOp(expr, Op.bitwise_xor),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(expr, pt.Op.bitwise_xor),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_bitwise_xor_overload():
-    args = [Int(1), Int(3), Int(5)]
+    args = [pt.Int(1), pt.Int(3), pt.Int(5)]
     expr = args[0] ^ args[1] ^ args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 3),
-            TealOp(None, Op.bitwise_xor),
-            TealOp(args[2], Op.int, 5),
-            TealOp(None, Op.bitwise_xor),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.bitwise_xor),
+            pt.TealOp(args[2], pt.Op.int, 5),
+            pt.TealOp(None, pt.Op.bitwise_xor),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_bitwise_xor_invalid():
-    with pytest.raises(TealTypeError):
-        BitwiseXor(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BitwiseXor(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BitwiseXor(Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BitwiseXor(pt.Txn.sender(), pt.Int(2))
 
 
 def test_shift_left():
-    args = [Int(5), Int(1)]
-    expr = ShiftLeft(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(5), pt.Int(1)]
+    expr = pt.ShiftLeft(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 5), TealOp(args[1], Op.int, 1), TealOp(expr, Op.shl)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 5),
+            pt.TealOp(args[1], pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.shl),
+        ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_shift_left_overload():
-    args = [Int(5), Int(1), Int(2)]
+    args = [pt.Int(5), pt.Int(1), pt.Int(2)]
     expr = args[0] << args[1] << args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 5),
-            TealOp(args[1], Op.int, 1),
-            TealOp(None, Op.shl),
-            TealOp(args[2], Op.int, 2),
-            TealOp(None, Op.shl),
+            pt.TealOp(args[0], pt.Op.int, 5),
+            pt.TealOp(args[1], pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.shl),
+            pt.TealOp(args[2], pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.shl),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_shift_left_invalid():
-    with pytest.raises(TealTypeError):
-        ShiftLeft(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.ShiftLeft(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        ShiftLeft(Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.ShiftLeft(pt.Txn.sender(), pt.Int(2))
 
 
 def test_shift_right():
-    args = [Int(5), Int(1)]
-    expr = ShiftRight(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(5), pt.Int(1)]
+    expr = pt.ShiftRight(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 5), TealOp(args[1], Op.int, 1), TealOp(expr, Op.shr)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 5),
+            pt.TealOp(args[1], pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.shr),
+        ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_shift_right_overload():
-    args = [Int(5), Int(1), Int(2)]
+    args = [pt.Int(5), pt.Int(1), pt.Int(2)]
     expr = args[0] >> args[1] >> args[2]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 5),
-            TealOp(args[1], Op.int, 1),
-            TealOp(None, Op.shr),
-            TealOp(args[2], Op.int, 2),
-            TealOp(None, Op.shr),
+            pt.TealOp(args[0], pt.Op.int, 5),
+            pt.TealOp(args[1], pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.shr),
+            pt.TealOp(args[2], pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.shr),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_shift_right_invalid():
-    with pytest.raises(TealTypeError):
-        ShiftRight(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.ShiftRight(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        ShiftRight(Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.ShiftRight(pt.Txn.sender(), pt.Int(2))
 
 
 def test_eq():
-    args_int = [Int(2), Int(3)]
-    expr_int = Eq(args_int[0], args_int[1])
-    assert expr_int.type_of() == TealType.uint64
+    args_int = [pt.Int(2), pt.Int(3)]
+    expr_int = pt.Eq(args_int[0], args_int[1])
+    assert expr_int.type_of() == pt.TealType.uint64
 
-    expected_int = TealSimpleBlock(
+    expected_int = pt.TealSimpleBlock(
         [
-            TealOp(args_int[0], Op.int, 2),
-            TealOp(args_int[1], Op.int, 3),
-            TealOp(expr_int, Op.eq),
+            pt.TealOp(args_int[0], pt.Op.int, 2),
+            pt.TealOp(args_int[1], pt.Op.int, 3),
+            pt.TealOp(expr_int, pt.Op.eq),
         ]
     )
 
     actual_int, _ = expr_int.__teal__(teal2Options)
     actual_int.addIncoming()
-    actual_int = TealBlock.NormalizeBlocks(actual_int)
+    actual_int = pt.TealBlock.NormalizeBlocks(actual_int)
 
     assert actual_int == expected_int
 
-    args_bytes = [Txn.receiver(), Txn.sender()]
-    expr_bytes = Eq(args_bytes[0], args_bytes[1])
-    assert expr_bytes.type_of() == TealType.uint64
+    args_bytes = [pt.Txn.receiver(), pt.Txn.sender()]
+    expr_bytes = pt.Eq(args_bytes[0], args_bytes[1])
+    assert expr_bytes.type_of() == pt.TealType.uint64
 
-    expected_bytes = TealSimpleBlock(
+    expected_bytes = pt.TealSimpleBlock(
         [
-            TealOp(args_bytes[0], Op.txn, "Receiver"),
-            TealOp(args_bytes[1], Op.txn, "Sender"),
-            TealOp(expr_bytes, Op.eq),
+            pt.TealOp(args_bytes[0], pt.Op.txn, "Receiver"),
+            pt.TealOp(args_bytes[1], pt.Op.txn, "Sender"),
+            pt.TealOp(expr_bytes, pt.Op.eq),
         ]
     )
 
     actual_bytes, _ = expr_bytes.__teal__(teal2Options)
     actual_bytes.addIncoming()
-    actual_bytes = TealBlock.NormalizeBlocks(actual_bytes)
+    actual_bytes = pt.TealBlock.NormalizeBlocks(actual_bytes)
 
     assert actual_bytes == expected_bytes
 
 
 def test_eq_overload():
-    args_int = [Int(2), Int(3)]
+    args_int = [pt.Int(2), pt.Int(3)]
     expr_int = args_int[0] == args_int[1]
-    assert expr_int.type_of() == TealType.uint64
+    assert expr_int.type_of() == pt.TealType.uint64
 
-    expected_int = TealSimpleBlock(
+    expected_int = pt.TealSimpleBlock(
         [
-            TealOp(args_int[0], Op.int, 2),
-            TealOp(args_int[1], Op.int, 3),
-            TealOp(expr_int, Op.eq),
+            pt.TealOp(args_int[0], pt.Op.int, 2),
+            pt.TealOp(args_int[1], pt.Op.int, 3),
+            pt.TealOp(expr_int, pt.Op.eq),
         ]
     )
 
     actual_int, _ = expr_int.__teal__(teal2Options)
     actual_int.addIncoming()
-    actual_int = TealBlock.NormalizeBlocks(actual_int)
+    actual_int = pt.TealBlock.NormalizeBlocks(actual_int)
 
     assert actual_int == expected_int
 
-    args_bytes = [Txn.receiver(), Txn.sender()]
+    args_bytes = [pt.Txn.receiver(), pt.Txn.sender()]
     expr_bytes = args_bytes[0] == args_bytes[1]
-    assert expr_bytes.type_of() == TealType.uint64
+    assert expr_bytes.type_of() == pt.TealType.uint64
 
-    expected_bytes = TealSimpleBlock(
+    expected_bytes = pt.TealSimpleBlock(
         [
-            TealOp(args_bytes[0], Op.txn, "Receiver"),
-            TealOp(args_bytes[1], Op.txn, "Sender"),
-            TealOp(expr_bytes, Op.eq),
+            pt.TealOp(args_bytes[0], pt.Op.txn, "Receiver"),
+            pt.TealOp(args_bytes[1], pt.Op.txn, "Sender"),
+            pt.TealOp(expr_bytes, pt.Op.eq),
         ]
     )
 
     actual_bytes, _ = expr_bytes.__teal__(teal2Options)
     actual_bytes.addIncoming()
-    actual_bytes = TealBlock.NormalizeBlocks(actual_bytes)
+    actual_bytes = pt.TealBlock.NormalizeBlocks(actual_bytes)
 
     assert actual_bytes == expected_bytes
 
 
 def test_eq_invalid():
-    with pytest.raises(TealTypeError):
-        Eq(Txn.fee(), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Eq(pt.Txn.fee(), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Eq(Txn.sender(), Int(7))
+    with pytest.raises(pt.TealTypeError):
+        pt.Eq(pt.Txn.sender(), pt.Int(7))
 
 
 def test_neq():
-    args_int = [Int(2), Int(3)]
-    expr_int = Neq(args_int[0], args_int[1])
-    assert expr_int.type_of() == TealType.uint64
+    args_int = [pt.Int(2), pt.Int(3)]
+    expr_int = pt.Neq(args_int[0], args_int[1])
+    assert expr_int.type_of() == pt.TealType.uint64
 
-    expected_int = TealSimpleBlock(
+    expected_int = pt.TealSimpleBlock(
         [
-            TealOp(args_int[0], Op.int, 2),
-            TealOp(args_int[1], Op.int, 3),
-            TealOp(expr_int, Op.neq),
+            pt.TealOp(args_int[0], pt.Op.int, 2),
+            pt.TealOp(args_int[1], pt.Op.int, 3),
+            pt.TealOp(expr_int, pt.Op.neq),
         ]
     )
 
     actual_int, _ = expr_int.__teal__(teal2Options)
     actual_int.addIncoming()
-    actual_int = TealBlock.NormalizeBlocks(actual_int)
+    actual_int = pt.TealBlock.NormalizeBlocks(actual_int)
 
     assert actual_int == expected_int
 
-    args_bytes = [Txn.receiver(), Txn.sender()]
-    expr_bytes = Neq(args_bytes[0], args_bytes[1])
-    assert expr_bytes.type_of() == TealType.uint64
+    args_bytes = [pt.Txn.receiver(), pt.Txn.sender()]
+    expr_bytes = pt.Neq(args_bytes[0], args_bytes[1])
+    assert expr_bytes.type_of() == pt.TealType.uint64
 
-    expected_bytes = TealSimpleBlock(
+    expected_bytes = pt.TealSimpleBlock(
         [
-            TealOp(args_bytes[0], Op.txn, "Receiver"),
-            TealOp(args_bytes[1], Op.txn, "Sender"),
-            TealOp(expr_bytes, Op.neq),
+            pt.TealOp(args_bytes[0], pt.Op.txn, "Receiver"),
+            pt.TealOp(args_bytes[1], pt.Op.txn, "Sender"),
+            pt.TealOp(expr_bytes, pt.Op.neq),
         ]
     )
 
     actual_bytes, _ = expr_bytes.__teal__(teal2Options)
     actual_bytes.addIncoming()
-    actual_bytes = TealBlock.NormalizeBlocks(actual_bytes)
+    actual_bytes = pt.TealBlock.NormalizeBlocks(actual_bytes)
 
     assert actual_bytes == expected_bytes
 
 
 def test_neq_overload():
-    args_int = [Int(2), Int(3)]
+    args_int = [pt.Int(2), pt.Int(3)]
     expr_int = args_int[0] != args_int[1]
-    assert expr_int.type_of() == TealType.uint64
+    assert expr_int.type_of() == pt.TealType.uint64
 
-    expected_int = TealSimpleBlock(
+    expected_int = pt.TealSimpleBlock(
         [
-            TealOp(args_int[0], Op.int, 2),
-            TealOp(args_int[1], Op.int, 3),
-            TealOp(expr_int, Op.neq),
+            pt.TealOp(args_int[0], pt.Op.int, 2),
+            pt.TealOp(args_int[1], pt.Op.int, 3),
+            pt.TealOp(expr_int, pt.Op.neq),
         ]
     )
 
     actual_int, _ = expr_int.__teal__(teal2Options)
     actual_int.addIncoming()
-    actual_int = TealBlock.NormalizeBlocks(actual_int)
+    actual_int = pt.TealBlock.NormalizeBlocks(actual_int)
 
     assert actual_int == expected_int
 
-    args_bytes = [Txn.receiver(), Txn.sender()]
+    args_bytes = [pt.Txn.receiver(), pt.Txn.sender()]
     expr_bytes = args_bytes[0] != args_bytes[1]
-    assert expr_bytes.type_of() == TealType.uint64
+    assert expr_bytes.type_of() == pt.TealType.uint64
 
-    expected_bytes = TealSimpleBlock(
+    expected_bytes = pt.TealSimpleBlock(
         [
-            TealOp(args_bytes[0], Op.txn, "Receiver"),
-            TealOp(args_bytes[1], Op.txn, "Sender"),
-            TealOp(expr_bytes, Op.neq),
+            pt.TealOp(args_bytes[0], pt.Op.txn, "Receiver"),
+            pt.TealOp(args_bytes[1], pt.Op.txn, "Sender"),
+            pt.TealOp(expr_bytes, pt.Op.neq),
         ]
     )
 
     actual_bytes, _ = expr_bytes.__teal__(teal2Options)
     actual_bytes.addIncoming()
-    actual_bytes = TealBlock.NormalizeBlocks(actual_bytes)
+    actual_bytes = pt.TealBlock.NormalizeBlocks(actual_bytes)
 
     assert actual_bytes == expected_bytes
 
 
 def test_neq_invalid():
-    with pytest.raises(TealTypeError):
-        Neq(Txn.fee(), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Neq(pt.Txn.fee(), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Neq(Txn.sender(), Int(7))
+    with pytest.raises(pt.TealTypeError):
+        pt.Neq(pt.Txn.sender(), pt.Int(7))
 
 
 def test_lt():
-    args = [Int(2), Int(3)]
-    expr = Lt(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(2), pt.Int(3)]
+    expr = pt.Lt(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 2), TealOp(args[1], Op.int, 3), TealOp(expr, Op.lt)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 2),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(expr, pt.Op.lt),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_lt_overload():
-    args = [Int(2), Int(3)]
+    args = [pt.Int(2), pt.Int(3)]
     expr = args[0] < args[1]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 2), TealOp(args[1], Op.int, 3), TealOp(expr, Op.lt)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 2),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(expr, pt.Op.lt),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_lt_invalid():
-    with pytest.raises(TealTypeError):
-        Lt(Int(7), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Lt(pt.Int(7), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Lt(Txn.sender(), Int(7))
+    with pytest.raises(pt.TealTypeError):
+        pt.Lt(pt.Txn.sender(), pt.Int(7))
 
 
 def test_le():
-    args = [Int(1), Int(2)]
-    expr = Le(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(1), pt.Int(2)]
+    expr = pt.Le(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 1), TealOp(args[1], Op.int, 2), TealOp(expr, Op.le)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(expr, pt.Op.le),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_le_overload():
-    args = [Int(1), Int(2)]
+    args = [pt.Int(1), pt.Int(2)]
     expr = args[0] <= args[1]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 1), TealOp(args[1], Op.int, 2), TealOp(expr, Op.le)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(expr, pt.Op.le),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_le_invalid():
-    with pytest.raises(TealTypeError):
-        Le(Int(1), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Le(pt.Int(1), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Le(Txn.sender(), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Le(pt.Txn.sender(), pt.Int(1))
 
 
 def test_gt():
-    args = [Int(2), Int(3)]
-    expr = Gt(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(2), pt.Int(3)]
+    expr = pt.Gt(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 2), TealOp(args[1], Op.int, 3), TealOp(expr, Op.gt)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 2),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(expr, pt.Op.gt),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_gt_overload():
-    args = [Int(2), Int(3)]
+    args = [pt.Int(2), pt.Int(3)]
     expr = args[0] > args[1]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 2), TealOp(args[1], Op.int, 3), TealOp(expr, Op.gt)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 2),
+            pt.TealOp(args[1], pt.Op.int, 3),
+            pt.TealOp(expr, pt.Op.gt),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_gt_invalid():
-    with pytest.raises(TealTypeError):
-        Gt(Int(1), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Gt(pt.Int(1), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Gt(Txn.receiver(), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Gt(pt.Txn.receiver(), pt.Int(1))
 
 
 def test_ge():
-    args = [Int(1), Int(10)]
-    expr = Ge(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(1), pt.Int(10)]
+    expr = pt.Ge(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 1), TealOp(args[1], Op.int, 10), TealOp(expr, Op.ge)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 10),
+            pt.TealOp(expr, pt.Op.ge),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_ge_overload():
-    args = [Int(1), Int(10)]
+    args = [pt.Int(1), pt.Int(10)]
     expr = args[0] >= args[1]
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(args[0], Op.int, 1), TealOp(args[1], Op.int, 10), TealOp(expr, Op.ge)]
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 10),
+            pt.TealOp(expr, pt.Op.ge),
+        ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_ge_invalid():
-    with pytest.raises(TealTypeError):
-        Ge(Int(1), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Ge(pt.Int(1), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Ge(Txn.receiver(), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Ge(pt.Txn.receiver(), pt.Int(1))
 
 
 def test_get_bit_int():
-    args = [Int(3), Int(1)]
-    expr = GetBit(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(3), pt.Int(1)]
+    expr = pt.GetBit(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 3),
-            TealOp(args[1], Op.int, 1),
-            TealOp(expr, Op.getbit),
+            pt.TealOp(args[0], pt.Op.int, 3),
+            pt.TealOp(args[1], pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.getbit),
         ]
     )
 
     actual, _ = expr.__teal__(teal3Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal2Options)
 
 
 def test_get_bit_bytes():
-    args = [Bytes("base16", "0xFF"), Int(1)]
-    expr = GetBit(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Bytes("base16", "0xFF"), pt.Int(1)]
+    expr = pt.GetBit(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFF"),
-            TealOp(args[1], Op.int, 1),
-            TealOp(expr, Op.getbit),
+            pt.TealOp(args[0], pt.Op.byte, "0xFF"),
+            pt.TealOp(args[1], pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.getbit),
         ]
     )
 
     actual, _ = expr.__teal__(teal3Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal2Options)
 
 
 def test_get_bit_invalid():
-    with pytest.raises(TealTypeError):
-        GetBit(Int(3), Bytes("index"))
+    with pytest.raises(pt.TealTypeError):
+        pt.GetBit(pt.Int(3), pt.Bytes("index"))
 
-    with pytest.raises(TealTypeError):
-        GetBit(Bytes("base16", "0xFF"), Bytes("index"))
+    with pytest.raises(pt.TealTypeError):
+        pt.GetBit(pt.Bytes("base16", "0xFF"), pt.Bytes("index"))
 
 
 def test_get_byte():
-    args = [Bytes("base16", "0xFF"), Int(0)]
-    expr = GetByte(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Bytes("base16", "0xFF"), pt.Int(0)]
+    expr = pt.GetByte(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFF"),
-            TealOp(args[1], Op.int, 0),
-            TealOp(expr, Op.getbyte),
+            pt.TealOp(args[0], pt.Op.byte, "0xFF"),
+            pt.TealOp(args[1], pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.getbyte),
         ]
     )
 
     actual, _ = expr.__teal__(teal3Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal2Options)
 
 
 def test_get_byte_invalid():
-    with pytest.raises(TealTypeError):
-        GetByte(Int(3), Int(0))
+    with pytest.raises(pt.TealTypeError):
+        pt.GetByte(pt.Int(3), pt.Int(0))
 
-    with pytest.raises(TealTypeError):
-        GetBit(Bytes("base16", "0xFF"), Bytes("index"))
+    with pytest.raises(pt.TealTypeError):
+        pt.GetBit(pt.Bytes("base16", "0xFF"), pt.Bytes("index"))
 
 
 def test_b_add():
     args = [
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFE"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFE"),
     ]
-    expr = BytesAdd(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    expr = pt.BytesAdd(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(args[1], Op.byte, "0xFFFFFFFFFFFFFFFFFE"),
-            TealOp(expr, Op.b_add),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFE"),
+            pt.TealOp(expr, pt.Op.b_add),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_add_invalid():
-    with pytest.raises(TealTypeError):
-        BytesAdd(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesAdd(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesAdd(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesAdd(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_minus():
     args = [
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFE"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFE"),
     ]
-    expr = BytesMinus(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    expr = pt.BytesMinus(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(args[1], Op.byte, "0xFFFFFFFFFFFFFFFFFE"),
-            TealOp(expr, Op.b_minus),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFE"),
+            pt.TealOp(expr, pt.Op.b_minus),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_minus_invalid():
-    with pytest.raises(TealTypeError):
-        BytesMinus(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesMinus(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesMinus(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesMinus(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_div():
-    args = [Bytes("base16", "0xFFFFFFFFFFFFFFFF00"), Bytes("base16", "0xFF")]
-    expr = BytesDiv(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("base16", "0xFFFFFFFFFFFFFFFF00"), pt.Bytes("base16", "0xFF")]
+    expr = pt.BytesDiv(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFF00"),
-            TealOp(args[1], Op.byte, "0xFF"),
-            TealOp(expr, Op.b_div),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFF00"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFF"),
+            pt.TealOp(expr, pt.Op.b_div),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_div_invalid():
-    with pytest.raises(TealTypeError):
-        BytesDiv(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesDiv(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesDiv(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesDiv(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_mul():
-    args = [Bytes("base16", "0xFFFFFFFFFFFFFFFF"), Bytes("base16", "0xFF")]
-    expr = BytesMul(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("base16", "0xFFFFFFFFFFFFFFFF"), pt.Bytes("base16", "0xFF")]
+    expr = pt.BytesMul(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFF"),
-            TealOp(args[1], Op.byte, "0xFF"),
-            TealOp(expr, Op.b_mul),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFF"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFF"),
+            pt.TealOp(expr, pt.Op.b_mul),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_mul_invalid():
-    with pytest.raises(TealTypeError):
-        BytesMul(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesMul(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesMul(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesMul(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_mod():
-    args = [Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"), Bytes("base16", "0xFF")]
-    expr = BytesMod(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"), pt.Bytes("base16", "0xFF")]
+    expr = pt.BytesMod(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(args[1], Op.byte, "0xFF"),
-            TealOp(expr, Op.b_mod),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFF"),
+            pt.TealOp(expr, pt.Op.b_mod),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_mod_invalid():
-    with pytest.raises(TealTypeError):
-        BytesMod(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesMod(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesMod(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesMod(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_and():
-    args = [Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"), Bytes("base16", "0xFF")]
-    expr = BytesAnd(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"), pt.Bytes("base16", "0xFF")]
+    expr = pt.BytesAnd(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
-            TealOp(args[1], Op.byte, "0xFF"),
-            TealOp(expr, Op.b_and),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFF"),
+            pt.TealOp(expr, pt.Op.b_and),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_and_invalid():
-    with pytest.raises(TealTypeError):
-        BytesAnd(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesAnd(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesAnd(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesAnd(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_or():
-    args = [Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"), Bytes("base16", "0xFF")]
-    expr = BytesOr(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"), pt.Bytes("base16", "0xFF")]
+    expr = pt.BytesOr(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
-            TealOp(args[1], Op.byte, "0xFF"),
-            TealOp(expr, Op.b_or),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFF"),
+            pt.TealOp(expr, pt.Op.b_or),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_or_invalid():
-    with pytest.raises(TealTypeError):
-        BytesOr(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesOr(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesOr(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesOr(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_xor():
-    args = [Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"), Bytes("base16", "0xFF")]
-    expr = BytesXor(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"), pt.Bytes("base16", "0xFF")]
+    expr = pt.BytesXor(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
-            TealOp(args[1], Op.byte, "0xFF"),
-            TealOp(expr, Op.b_xor),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFF"),
+            pt.TealOp(expr, pt.Op.b_xor),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_xor_invalid():
-    with pytest.raises(TealTypeError):
-        BytesXor(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesXor(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesXor(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesXor(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_eq():
     args = [
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
     ]
-    expr = BytesEq(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    expr = pt.BytesEq(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(args[1], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(expr, Op.b_eq),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(expr, pt.Op.b_eq),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_eq_invalid():
-    with pytest.raises(TealTypeError):
-        BytesEq(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesEq(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesEq(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesEq(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_neq():
     args = [
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
     ]
-    expr = BytesNeq(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    expr = pt.BytesNeq(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(args[1], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(expr, Op.b_neq),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(expr, pt.Op.b_neq),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_neq_invalid():
-    with pytest.raises(TealTypeError):
-        BytesNeq(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesNeq(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesNeq(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesNeq(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_lt():
     args = [
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"),
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
     ]
-    expr = BytesLt(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    expr = pt.BytesLt(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
-            TealOp(args[1], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(expr, Op.b_lt),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(expr, pt.Op.b_lt),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_lt_invalid():
-    with pytest.raises(TealTypeError):
-        BytesLt(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesLt(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesLt(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesLt(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_le():
     args = [
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"),
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
     ]
-    expr = BytesLe(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    expr = pt.BytesLe(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
-            TealOp(args[1], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(expr, Op.b_le),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(expr, pt.Op.b_le),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_le_invalid():
-    with pytest.raises(TealTypeError):
-        BytesLe(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesLe(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesLe(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesLe(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_gt():
     args = [
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"),
     ]
-    expr = BytesGt(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    expr = pt.BytesGt(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(args[1], Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
-            TealOp(expr, Op.b_gt),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
+            pt.TealOp(expr, pt.Op.b_gt),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_gt_invalid():
-    with pytest.raises(TealTypeError):
-        BytesGt(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesGt(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesGt(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesGt(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_b_ge():
     args = [
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
-        Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+        pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFF0"),
     ]
-    expr = BytesGe(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    expr = pt.BytesGe(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-            TealOp(args[1], Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
-            TealOp(expr, Op.b_ge),
+            pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(args[1], pt.Op.byte, "0xFFFFFFFFFFFFFFFFF0"),
+            pt.TealOp(expr, pt.Op.b_ge),
         ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_b_ge_invalid():
-    with pytest.raises(TealTypeError):
-        BytesGe(Int(2), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesGe(pt.Int(2), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        BytesGe(Bytes("base16", "0xFF"), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesGe(pt.Bytes("base16", "0xFF"), pt.Int(2))
 
 
 def test_extract_uint():
     for expression, op in (
-        (ExtractUint16, Op.extract_uint16),
-        (ExtractUint32, Op.extract_uint32),
-        (ExtractUint64, Op.extract_uint64),
+        (pt.ExtractUint16, pt.Op.extract_uint16),
+        (pt.ExtractUint32, pt.Op.extract_uint32),
+        (pt.ExtractUint64, pt.Op.extract_uint64),
     ):
         args = [
-            Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
-            Int(2),
+            pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF"),
+            pt.Int(2),
         ]
         expr = expression(args[0], args[1])
-        assert expr.type_of() == TealType.uint64
+        assert expr.type_of() == pt.TealType.uint64
 
-        expected = TealSimpleBlock(
+        expected = pt.TealSimpleBlock(
             [
-                TealOp(args[0], Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
-                TealOp(args[1], Op.int, 2),
-                TealOp(expr, op),
+                pt.TealOp(args[0], pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+                pt.TealOp(args[1], pt.Op.int, 2),
+                pt.TealOp(expr, op),
             ]
         )
 
         actual, _ = expr.__teal__(teal5Options)
         actual.addIncoming()
-        actual = TealBlock.NormalizeBlocks(actual)
+        actual = pt.TealBlock.NormalizeBlocks(actual)
 
         assert actual == expected
 
-        with pytest.raises(TealInputError):
+        with pytest.raises(pt.TealInputError):
             expr.__teal__(teal4Options)
 
 
 def test_extract_uint_invalid():
-    for expression in (ExtractUint16, ExtractUint32, ExtractUint64):
-        with pytest.raises(TealTypeError):
-            expression(Int(2), Txn.receiver())
+    for expression in (pt.ExtractUint16, pt.ExtractUint32, pt.ExtractUint64):
+        with pytest.raises(pt.TealTypeError):
+            expression(pt.Int(2), pt.Txn.receiver())
 
-        with pytest.raises(TealTypeError):
-            expression(Bytes("base16", "0xFF"), Txn.receiver())
+        with pytest.raises(pt.TealTypeError):
+            expression(pt.Bytes("base16", "0xFF"), pt.Txn.receiver())
diff --git a/pyteal/ast/break_test.py b/pyteal/ast/break_test.py
index e99568266..1e6684692 100644
--- a/pyteal/ast/break_test.py
+++ b/pyteal/ast/break_test.py
@@ -1,36 +1,33 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_break_fail():
 
-    with pytest.raises(TealCompileError):
-        Break().__teal__(options)
+    with pytest.raises(pt.TealCompileError):
+        pt.Break().__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        If(Int(1), Break()).__teal__(options)
+    with pytest.raises(pt.TealCompileError):
+        pt.If(pt.Int(1), pt.Break()).__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        Seq([Break()]).__teal__(options)
+    with pytest.raises(pt.TealCompileError):
+        pt.Seq([pt.Break()]).__teal__(options)
 
     with pytest.raises(TypeError):
-        Break(Int(1))
+        pt.Break(pt.Int(1))
 
 
 def test_break():
 
-    expr = Break()
+    expr = pt.Break()
 
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
-    expected = TealSimpleBlock([])
+    expected = pt.TealSimpleBlock([])
 
     options.enterLoop()
     actual, _ = expr.__teal__(options)
diff --git a/pyteal/ast/bytes_test.py b/pyteal/ast/bytes_test.py
index 3f0bb49f4..2ad5382a5 100644
--- a/pyteal/ast/bytes_test.py
+++ b/pyteal/ast/bytes_test.py
@@ -1,11 +1,8 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_bytes_base32_no_padding():
@@ -17,9 +14,11 @@ def test_bytes_base32_no_padding():
         "MFRGGZDF",
         "7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M",
     ):
-        expr = Bytes("base32", s)
-        assert expr.type_of() == TealType.bytes
-        expected = TealSimpleBlock([TealOp(expr, Op.byte, "base32(" + s + ")")])
+        expr = pt.Bytes("base32", s)
+        assert expr.type_of() == pt.TealType.bytes
+        expected = pt.TealSimpleBlock(
+            [pt.TealOp(expr, pt.Op.byte, "base32(" + s + ")")]
+        )
         actual, _ = expr.__teal__(options)
         assert actual == expected
 
@@ -32,141 +31,147 @@ def test_bytes_base32_padding():
         "MFRGGZA=",
         "7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M======",
     ):
-        expr = Bytes("base32", s)
-        assert expr.type_of() == TealType.bytes
-        expected = TealSimpleBlock([TealOp(expr, Op.byte, "base32(" + s + ")")])
+        expr = pt.Bytes("base32", s)
+        assert expr.type_of() == pt.TealType.bytes
+        expected = pt.TealSimpleBlock(
+            [pt.TealOp(expr, pt.Op.byte, "base32(" + s + ")")]
+        )
         actual, _ = expr.__teal__(options)
         assert actual == expected
 
 
 def test_bytes_base32_empty():
-    expr = Bytes("base32", "")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock([TealOp(expr, Op.byte, "base32()")])
+    expr = pt.Bytes("base32", "")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, "base32()")])
     actual, _ = expr.__teal__(options)
     assert actual == expected
 
 
 def test_bytes_base64():
-    expr = Bytes("base64", "Zm9vYmE=")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock([TealOp(expr, Op.byte, "base64(Zm9vYmE=)")])
+    expr = pt.Bytes("base64", "Zm9vYmE=")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, "base64(Zm9vYmE=)")])
     actual, _ = expr.__teal__(options)
     assert actual == expected
 
 
 def test_bytes_base64_empty():
-    expr = Bytes("base64", "")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock([TealOp(expr, Op.byte, "base64()")])
+    expr = pt.Bytes("base64", "")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, "base64()")])
     actual, _ = expr.__teal__(options)
     assert actual == expected
 
 
 def test_bytes_base16():
-    expr = Bytes("base16", "A21212EF")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock([TealOp(expr, Op.byte, "0xA21212EF")])
+    expr = pt.Bytes("base16", "A21212EF")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, "0xA21212EF")])
     actual, _ = expr.__teal__(options)
     assert actual == expected
 
 
 def test_bytes_base16_prefix():
-    expr = Bytes("base16", "0xA21212EF")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock([TealOp(expr, Op.byte, "0xA21212EF")])
+    expr = pt.Bytes("base16", "0xA21212EF")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, "0xA21212EF")])
     actual, _ = expr.__teal__(options)
     assert actual == expected
 
 
 def test_bytes_base16_empty():
-    expr = Bytes("base16", "")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock([TealOp(expr, Op.byte, "0x")])
+    expr = pt.Bytes("base16", "")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, "0x")])
     actual, _ = expr.__teal__(options)
     assert actual == expected
 
 
 def test_bytes_utf8():
-    expr = Bytes("hello world")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock([TealOp(expr, Op.byte, '"hello world"')])
+    expr = pt.Bytes("hello world")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, '"hello world"')])
     actual, _ = expr.__teal__(options)
     assert actual == expected
 
 
 def test_bytes_utf8_special_chars():
-    expr = Bytes("\t \n \r\n \\ \" ' 😀")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock(
-        [TealOp(expr, Op.byte, '"\\t \\n \\r\\n \\\\ \\" \' \\xf0\\x9f\\x98\\x80"')]
+    expr = pt.Bytes("\t \n \r\n \\ \" ' 😀")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(
+                expr, pt.Op.byte, '"\\t \\n \\r\\n \\\\ \\" \' \\xf0\\x9f\\x98\\x80"'
+            )
+        ]
     )
     actual, _ = expr.__teal__(options)
     assert actual == expected
 
 
 def test_bytes_utf8_empty():
-    expr = Bytes("")
-    assert expr.type_of() == TealType.bytes
-    expected = TealSimpleBlock([TealOp(expr, Op.byte, '""')])
+    expr = pt.Bytes("")
+    assert expr.type_of() == pt.TealType.bytes
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, '""')])
     actual, _ = expr.__teal__(options)
     assert actual == expected
 
 
 def test_bytes_raw():
     for value in (b"hello world", bytearray(b"hello world")):
-        expr = Bytes(value)
-        assert expr.type_of() == TealType.bytes
-        expected = TealSimpleBlock([TealOp(expr, Op.byte, "0x" + value.hex())])
+        expr = pt.Bytes(value)
+        assert expr.type_of() == pt.TealType.bytes
+        expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, "0x" + value.hex())])
         actual, _ = expr.__teal__(options)
         assert actual == expected
 
 
 def test_bytes_raw_empty():
     for value in (b"", bytearray(b"")):
-        expr = Bytes(value)
-        assert expr.type_of() == TealType.bytes
-        expected = TealSimpleBlock([TealOp(expr, Op.byte, "0x")])
+        expr = pt.Bytes(value)
+        assert expr.type_of() == pt.TealType.bytes
+        expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, "0x")])
         actual, _ = expr.__teal__(options)
         assert actual == expected
 
 
 def test_bytes_invalid():
-    with pytest.raises(TealInputError):
-        Bytes("base16", b"FF")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base16", b"FF")
 
-    with pytest.raises(TealInputError):
-        Bytes(b"base16", "FF")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes(b"base16", "FF")
 
-    with pytest.raises(TealInputError):
-        Bytes("base23", "")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base23", "")
 
-    with pytest.raises(TealInputError):
-        Bytes("base32", "Zm9vYmE=")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base32", "Zm9vYmE=")
 
-    with pytest.raises(TealInputError):
-        Bytes("base32", "MFRGG====")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base32", "MFRGG====")
 
-    with pytest.raises(TealInputError):
-        Bytes("base32", "MFRGG==")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base32", "MFRGG==")
 
-    with pytest.raises(TealInputError):
-        Bytes("base32", "CCCCCC==")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base32", "CCCCCC==")
 
-    with pytest.raises(TealInputError):
-        Bytes("base32", "CCCCCC")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base32", "CCCCCC")
 
-    with pytest.raises(TealInputError):
-        Bytes("base32", "C=======")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base32", "C=======")
 
-    with pytest.raises(TealInputError):
-        Bytes("base32", "C")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base32", "C")
 
-    with pytest.raises(TealInputError):
-        Bytes("base32", "=")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base32", "=")
 
-    with pytest.raises(TealInputError):
-        Bytes("base64", "?????")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base64", "?????")
 
-    with pytest.raises(TealInputError):
-        Bytes("base16", "7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M")
+    with pytest.raises(pt.TealInputError):
+        pt.Bytes("base16", "7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M")
diff --git a/pyteal/ast/cond_test.py b/pyteal/ast/cond_test.py
index 419030e39..9a8f8f8c1 100644
--- a/pyteal/ast/cond_test.py
+++ b/pyteal/ast/cond_test.py
@@ -1,43 +1,40 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_cond_one_pred():
-    expr = Cond([Int(1), Int(2)])
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Cond([pt.Int(1), pt.Int(2)])
+    assert expr.type_of() == pt.TealType.uint64
 
-    cond1, _ = Int(1).__teal__(options)
-    pred1, _ = Int(2).__teal__(options)
-    cond1Branch = TealConditionalBlock([])
+    cond1, _ = pt.Int(1).__teal__(options)
+    pred1, _ = pt.Int(2).__teal__(options)
+    cond1Branch = pt.TealConditionalBlock([])
     cond1.setNextBlock(cond1Branch)
     cond1Branch.setTrueBlock(pred1)
-    cond1Branch.setFalseBlock(Err().__teal__(options)[0])
-    pred1.setNextBlock(TealSimpleBlock([]))
+    cond1Branch.setFalseBlock(pt.Err().__teal__(options)[0])
+    pred1.setNextBlock(pt.TealSimpleBlock([]))
     expected = cond1
 
     actual, _ = expr.__teal__(options)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_cond_two_pred():
-    expr = Cond([Int(1), Bytes("one")], [Int(0), Bytes("zero")])
-    assert expr.type_of() == TealType.bytes
+    expr = pt.Cond([pt.Int(1), pt.Bytes("one")], [pt.Int(0), pt.Bytes("zero")])
+    assert expr.type_of() == pt.TealType.bytes
 
-    cond1, _ = Int(1).__teal__(options)
-    pred1, _ = Bytes("one").__teal__(options)
-    cond1Branch = TealConditionalBlock([])
-    cond2, _ = Int(0).__teal__(options)
-    pred2, _ = Bytes("zero").__teal__(options)
-    cond2Branch = TealConditionalBlock([])
-    end = TealSimpleBlock([])
+    cond1, _ = pt.Int(1).__teal__(options)
+    pred1, _ = pt.Bytes("one").__teal__(options)
+    cond1Branch = pt.TealConditionalBlock([])
+    cond2, _ = pt.Int(0).__teal__(options)
+    pred2, _ = pt.Bytes("zero").__teal__(options)
+    cond2Branch = pt.TealConditionalBlock([])
+    end = pt.TealSimpleBlock([])
 
     cond1.setNextBlock(cond1Branch)
     cond1Branch.setTrueBlock(pred1)
@@ -46,31 +43,33 @@ def test_cond_two_pred():
 
     cond2.setNextBlock(cond2Branch)
     cond2Branch.setTrueBlock(pred2)
-    cond2Branch.setFalseBlock(Err().__teal__(options)[0])
+    cond2Branch.setFalseBlock(pt.Err().__teal__(options)[0])
     pred2.setNextBlock(end)
 
     expected = cond1
 
     actual, _ = expr.__teal__(options)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_cond_three_pred():
-    expr = Cond([Int(1), Int(2)], [Int(3), Int(4)], [Int(5), Int(6)])
-    assert expr.type_of() == TealType.uint64
-
-    cond1, _ = Int(1).__teal__(options)
-    pred1, _ = Int(2).__teal__(options)
-    cond1Branch = TealConditionalBlock([])
-    cond2, _ = Int(3).__teal__(options)
-    pred2, _ = Int(4).__teal__(options)
-    cond2Branch = TealConditionalBlock([])
-    cond3, _ = Int(5).__teal__(options)
-    pred3, _ = Int(6).__teal__(options)
-    cond3Branch = TealConditionalBlock([])
-    end = TealSimpleBlock([])
+    expr = pt.Cond(
+        [pt.Int(1), pt.Int(2)], [pt.Int(3), pt.Int(4)], [pt.Int(5), pt.Int(6)]
+    )
+    assert expr.type_of() == pt.TealType.uint64
+
+    cond1, _ = pt.Int(1).__teal__(options)
+    pred1, _ = pt.Int(2).__teal__(options)
+    cond1Branch = pt.TealConditionalBlock([])
+    cond2, _ = pt.Int(3).__teal__(options)
+    pred2, _ = pt.Int(4).__teal__(options)
+    cond2Branch = pt.TealConditionalBlock([])
+    cond3, _ = pt.Int(5).__teal__(options)
+    pred3, _ = pt.Int(6).__teal__(options)
+    cond3Branch = pt.TealConditionalBlock([])
+    end = pt.TealSimpleBlock([])
 
     cond1.setNextBlock(cond1Branch)
     cond1Branch.setTrueBlock(pred1)
@@ -84,39 +83,44 @@ def test_cond_three_pred():
 
     cond3.setNextBlock(cond3Branch)
     cond3Branch.setTrueBlock(pred3)
-    cond3Branch.setFalseBlock(Err().__teal__(options)[0])
+    cond3Branch.setFalseBlock(pt.Err().__teal__(options)[0])
     pred3.setNextBlock(end)
 
     expected = cond1
 
     actual, _ = expr.__teal__(options)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_cond_has_return():
-    exprWithReturn = Cond([Int(1), Return(Int(1))], [Int(0), Return(Int(0))])
+    exprWithReturn = pt.Cond(
+        [pt.Int(1), pt.Return(pt.Int(1))], [pt.Int(0), pt.Return(pt.Int(0))]
+    )
     assert exprWithReturn.has_return()
 
-    exprWithoutReturn = Cond([Int(1), Bytes("one")], [Int(0), Bytes("zero")])
+    exprWithoutReturn = pt.Cond(
+        [pt.Int(1), pt.Bytes("one")], [pt.Int(0), pt.Bytes("zero")]
+    )
     assert not exprWithoutReturn.has_return()
 
-    exprSemiReturn = Cond(
-        [Int(1), Return(Int(1))], [Int(0), App.globalPut(Bytes("key"), Bytes("value"))]
+    exprSemiReturn = pt.Cond(
+        [pt.Int(1), pt.Return(pt.Int(1))],
+        [pt.Int(0), pt.App.globalPut(pt.Bytes("key"), pt.Bytes("value"))],
     )
     assert not exprSemiReturn.has_return()
 
 
 def test_cond_invalid():
-    with pytest.raises(TealInputError):
-        Cond()
+    with pytest.raises(pt.TealInputError):
+        pt.Cond()
 
-    with pytest.raises(TealInputError):
-        Cond([])
+    with pytest.raises(pt.TealInputError):
+        pt.Cond([])
 
-    with pytest.raises(TealTypeError):
-        Cond([Int(1), Int(2)], [Int(2), Txn.receiver()])
+    with pytest.raises(pt.TealTypeError):
+        pt.Cond([pt.Int(1), pt.Int(2)], [pt.Int(2), pt.Txn.receiver()])
 
-    with pytest.raises(TealTypeError):
-        Cond([Arg(0), Int(2)])
+    with pytest.raises(pt.TealTypeError):
+        pt.Cond([pt.Arg(0), pt.Int(2)])
diff --git a/pyteal/ast/continue_test.py b/pyteal/ast/continue_test.py
index 30f4ccb08..3a310934c 100644
--- a/pyteal/ast/continue_test.py
+++ b/pyteal/ast/continue_test.py
@@ -1,35 +1,32 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_continue_fail():
-    with pytest.raises(TealCompileError):
-        Continue().__teal__(options)
+    with pytest.raises(pt.TealCompileError):
+        pt.Continue().__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        If(Int(1), Continue()).__teal__(options)
+    with pytest.raises(pt.TealCompileError):
+        pt.If(pt.Int(1), pt.Continue()).__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        Seq([Continue()]).__teal__(options)
+    with pytest.raises(pt.TealCompileError):
+        pt.Seq([pt.Continue()]).__teal__(options)
 
     with pytest.raises(TypeError):
-        Continue(Int(1))
+        pt.Continue(pt.Int(1))
 
 
 def test_continue():
 
-    expr = Continue()
+    expr = pt.Continue()
 
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
-    expected = TealSimpleBlock([])
+    expected = pt.TealSimpleBlock([])
 
     options.enterLoop()
     actual, _ = expr.__teal__(options)
diff --git a/pyteal/ast/err_test.py b/pyteal/ast/err_test.py
index aec4e51ca..7e95383df 100644
--- a/pyteal/ast/err_test.py
+++ b/pyteal/ast/err_test.py
@@ -1,12 +1,10 @@
-import pytest
-
-from .. import *
+import pyteal as pt
 
 
 def test_err():
-    expr = Err()
-    assert expr.type_of() == TealType.none
+    expr = pt.Err()
+    assert expr.type_of() == pt.TealType.none
     assert expr.has_return()
-    expected = TealSimpleBlock([TealOp(expr, Op.err)])
-    actual, _ = expr.__teal__(CompileOptions())
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.err)])
+    actual, _ = expr.__teal__(pt.CompileOptions())
     assert actual == expected
diff --git a/pyteal/ast/for_test.py b/pyteal/ast/for_test.py
index a5ccfbb2f..87151a374 100644
--- a/pyteal/ast/for_test.py
+++ b/pyteal/ast/for_test.py
@@ -1,68 +1,65 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_for_compiles():
-    i = ScratchVar()
+    i = pt.ScratchVar()
 
-    expr = For(i.store(Int(0)), Int(1), i.store(i.load() + Int(1))).Do(
-        App.globalPut(Itob(Int(0)), Itob(Int(2)))
+    expr = pt.For(i.store(pt.Int(0)), pt.Int(1), i.store(i.load() + pt.Int(1))).Do(
+        pt.App.globalPut(pt.Itob(pt.Int(0)), pt.Itob(pt.Int(2)))
     )
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
     expr.__teal__(options)
 
 
 def test_nested_for_compiles():
-    i = ScratchVar()
-    expr = For(i.store(Int(0)), Int(1), i.store(i.load() + Int(1))).Do(
-        Seq(
+    i = pt.ScratchVar()
+    expr = pt.For(i.store(pt.Int(0)), pt.Int(1), i.store(i.load() + pt.Int(1))).Do(
+        pt.Seq(
             [
-                For(i.store(Int(0)), Int(1), i.store(i.load() + Int(1))).Do(
-                    Seq([i.store(Int(0))])
+                pt.For(i.store(pt.Int(0)), pt.Int(1), i.store(i.load() + pt.Int(1))).Do(
+                    pt.Seq([i.store(pt.Int(0))])
                 )
             ]
         )
     )
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
 
 def test_continue_break():
-    i = ScratchVar()
-    expr = For(i.store(Int(0)), Int(1), i.store(i.load() + Int(1))).Do(
-        Seq([If(Int(1), Break(), Continue())])
+    i = pt.ScratchVar()
+    expr = pt.For(i.store(pt.Int(0)), pt.Int(1), i.store(i.load() + pt.Int(1))).Do(
+        pt.Seq([pt.If(pt.Int(1), pt.Break(), pt.Continue())])
     )
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
     expr.__teal__(options)
 
 
 def test_for():
-    i = ScratchVar()
+    i = pt.ScratchVar()
     items = [
-        (i.store(Int(0))),
-        i.load() < Int(10),
-        i.store(i.load() + Int(1)),
-        App.globalPut(Itob(i.load()), i.load() * Int(2)),
+        (i.store(pt.Int(0))),
+        i.load() < pt.Int(10),
+        i.store(i.load() + pt.Int(1)),
+        pt.App.globalPut(pt.Itob(i.load()), i.load() * pt.Int(2)),
     ]
-    expr = For(items[0], items[1], items[2]).Do(Seq([items[3]]))
+    expr = pt.For(items[0], items[1], items[2]).Do(pt.Seq([items[3]]))
 
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
     expected, varEnd = items[0].__teal__(options)
     condStart, condEnd = items[1].__teal__(options)
     stepStart, stepEnd = items[2].__teal__(options)
-    do, doEnd = Seq([items[3]]).__teal__(options)
-    expectedBranch = TealConditionalBlock([])
-    end = TealSimpleBlock([])
+    do, doEnd = pt.Seq([items[3]]).__teal__(options)
+    expectedBranch = pt.TealConditionalBlock([])
+    end = pt.TealSimpleBlock([])
 
     varEnd.setNextBlock(condStart)
     doEnd.setNextBlock(stepStart)
@@ -78,17 +75,17 @@ def test_for():
 
 
 def test_for_continue():
-    i = ScratchVar()
+    i = pt.ScratchVar()
     items = [
-        (i.store(Int(0))),
-        i.load() < Int(10),
-        i.store(i.load() + Int(1)),
-        If(i.load() < Int(4), Continue()),
-        App.globalPut(Itob(i.load()), i.load() * Int(2)),
+        (i.store(pt.Int(0))),
+        i.load() < pt.Int(10),
+        i.store(i.load() + pt.Int(1)),
+        pt.If(i.load() < pt.Int(4), pt.Continue()),
+        pt.App.globalPut(pt.Itob(i.load()), i.load() * pt.Int(2)),
     ]
-    expr = For(items[0], items[1], items[2]).Do(Seq([items[3], items[4]]))
+    expr = pt.For(items[0], items[1], items[2]).Do(pt.Seq([items[3], items[4]]))
 
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
     options.enterLoop()
@@ -96,9 +93,9 @@ def test_for_continue():
     expected, varEnd = items[0].__teal__(options)
     condStart, condEnd = items[1].__teal__(options)
     stepStart, stepEnd = items[2].__teal__(options)
-    do, doEnd = Seq([items[3], items[4]]).__teal__(options)
-    expectedBranch = TealConditionalBlock([])
-    end = TealSimpleBlock([])
+    do, doEnd = pt.Seq([items[3], items[4]]).__teal__(options)
+    expectedBranch = pt.TealConditionalBlock([])
+    end = pt.TealSimpleBlock([])
 
     doEnd.setNextBlock(stepStart)
     stepEnd.setNextBlock(condStart)
@@ -119,17 +116,17 @@ def test_for_continue():
 
 
 def test_for_break():
-    i = ScratchVar()
+    i = pt.ScratchVar()
     items = [
-        (i.store(Int(0))),
-        i.load() < Int(10),
-        i.store(i.load() + Int(1)),
-        If(i.load() == Int(6), Break()),
-        App.globalPut(Itob(i.load()), i.load() * Int(2)),
+        (i.store(pt.Int(0))),
+        i.load() < pt.Int(10),
+        i.store(i.load() + pt.Int(1)),
+        pt.If(i.load() == pt.Int(6), pt.Break()),
+        pt.App.globalPut(pt.Itob(i.load()), i.load() * pt.Int(2)),
     ]
-    expr = For(items[0], items[1], items[2]).Do(Seq([items[3], items[4]]))
+    expr = pt.For(items[0], items[1], items[2]).Do(pt.Seq([items[3], items[4]]))
 
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
     options.enterLoop()
@@ -137,9 +134,9 @@ def test_for_break():
     expected, varEnd = items[0].__teal__(options)
     condStart, condEnd = items[1].__teal__(options)
     stepStart, stepEnd = items[2].__teal__(options)
-    do, doEnd = Seq([items[3], items[4]]).__teal__(options)
-    expectedBranch = TealConditionalBlock([])
-    end = TealSimpleBlock([])
+    do, doEnd = pt.Seq([items[3], items[4]]).__teal__(options)
+    expectedBranch = pt.TealConditionalBlock([])
+    end = pt.TealSimpleBlock([])
 
     doEnd.setNextBlock(stepStart)
     stepEnd.setNextBlock(condStart)
@@ -161,37 +158,39 @@ def test_for_break():
 
 def test_invalid_for():
     with pytest.raises(TypeError):
-        expr = For()
+        expr = pt.For()
 
     with pytest.raises(TypeError):
-        expr = For(Int(2))
+        expr = pt.For(pt.Int(2))
 
     with pytest.raises(TypeError):
-        expr = For(Int(1), Int(2))
+        expr = pt.For(pt.Int(1), pt.Int(2))
 
-    with pytest.raises(TealTypeError):
-        i = ScratchVar()
-        expr = For(i.store(Int(0)), Int(1), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        i = pt.ScratchVar()
+        expr = pt.For(i.store(pt.Int(0)), pt.Int(1), pt.Int(2))
         expr.__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        i = ScratchVar()
-        expr = For(i.store(Int(0)), Int(1), i.store(i.load() + Int(1)))
+    with pytest.raises(pt.TealCompileError):
+        i = pt.ScratchVar()
+        expr = pt.For(i.store(pt.Int(0)), pt.Int(1), i.store(i.load() + pt.Int(1)))
         expr.type_of()
 
-    with pytest.raises(TealCompileError):
-        i = ScratchVar()
-        expr = For(i.store(Int(0)), Int(1), i.store(i.load() + Int(1)))
+    with pytest.raises(pt.TealCompileError):
+        i = pt.ScratchVar()
+        expr = pt.For(i.store(pt.Int(0)), pt.Int(1), i.store(i.load() + pt.Int(1)))
         expr.__str__()
 
-    with pytest.raises(TealTypeError):
-        i = ScratchVar()
-        expr = For(i.store(Int(0)), Int(1), i.store(i.load() + Int(1))).Do(Int(0))
+    with pytest.raises(pt.TealTypeError):
+        i = pt.ScratchVar()
+        expr = pt.For(i.store(pt.Int(0)), pt.Int(1), i.store(i.load() + pt.Int(1))).Do(
+            pt.Int(0)
+        )
 
-    with pytest.raises(TealCompileError):
+    with pytest.raises(pt.TealCompileError):
         expr = (
-            For(i.store(Int(0)), Int(1), i.store(i.load() + Int(1)))
-            .Do(Continue())
-            .Do(Continue())
+            pt.For(i.store(pt.Int(0)), pt.Int(1), i.store(i.load() + pt.Int(1)))
+            .Do(pt.Continue())
+            .Do(pt.Continue())
         )
         expr.__str__()
diff --git a/pyteal/ast/gaid_test.py b/pyteal/ast/gaid_test.py
index d42f57de2..9da4fe254 100644
--- a/pyteal/ast/gaid_test.py
+++ b/pyteal/ast/gaid_test.py
@@ -1,24 +1,21 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import MAX_GROUP_SIZE, CompileOptions
-
-teal3Options = CompileOptions(version=3)
-teal4Options = CompileOptions(version=4)
+teal3Options = pt.CompileOptions(version=3)
+teal4Options = pt.CompileOptions(version=4)
 
 
 def test_gaid_teal_3():
-    with pytest.raises(TealInputError):
-        GeneratedID(0).__teal__(teal3Options)
+    with pytest.raises(pt.TealInputError):
+        pt.GeneratedID(0).__teal__(teal3Options)
 
 
 def test_gaid():
-    expr = GeneratedID(0)
-    assert expr.type_of() == TealType.uint64
+    expr = pt.GeneratedID(0)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.gaid, 0)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.gaid, 0)])
 
     actual, _ = expr.__teal__(teal4Options)
 
@@ -26,32 +23,34 @@ def test_gaid():
 
 
 def test_gaid_invalid():
-    with pytest.raises(TealInputError):
-        GeneratedID(-1)
+    with pytest.raises(pt.TealInputError):
+        pt.GeneratedID(-1)
 
-    with pytest.raises(TealInputError):
-        GeneratedID(MAX_GROUP_SIZE)
+    with pytest.raises(pt.TealInputError):
+        pt.GeneratedID(pt.MAX_GROUP_SIZE)
 
 
 def test_gaid_dynamic_teal_3():
-    with pytest.raises(TealInputError):
-        GeneratedID(Int(0)).__teal__(teal3Options)
+    with pytest.raises(pt.TealInputError):
+        pt.GeneratedID(pt.Int(0)).__teal__(teal3Options)
 
 
 def test_gaid_dynamic():
-    arg = Int(0)
-    expr = GeneratedID(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(0)
+    expr = pt.GeneratedID(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 0), TealOp(expr, Op.gaids)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 0), pt.TealOp(expr, pt.Op.gaids)]
+    )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_gaid_dynamic_invalid():
-    with pytest.raises(TealTypeError):
-        GeneratedID(Bytes("index"))
+    with pytest.raises(pt.TealTypeError):
+        pt.GeneratedID(pt.Bytes("index"))
diff --git a/pyteal/ast/gitxn_test.py b/pyteal/ast/gitxn_test.py
index ab950067b..44415df83 100644
--- a/pyteal/ast/gitxn_test.py
+++ b/pyteal/ast/gitxn_test.py
@@ -1,20 +1,20 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-teal5Options = CompileOptions(version=5)
-teal6Options = CompileOptions(version=6)
+teal5Options = pt.CompileOptions(version=5)
+teal6Options = pt.CompileOptions(version=6)
 
 
 def test_gitxn_invalid():
     for ctor, e in [
         (
-            lambda: Gitxn[MAX_GROUP_SIZE],
-            TealInputError,
+            lambda: pt.Gitxn[pt.MAX_GROUP_SIZE],
+            pt.TealInputError,
         ),
         (
-            lambda: Gitxn[-1],
-            TealInputError,
+            lambda: pt.Gitxn[-1],
+            pt.TealInputError,
         ),
     ]:
         with pytest.raises(e):
@@ -22,19 +22,19 @@ def test_gitxn_invalid():
 
 
 def test_gitxn_valid():
-    for i in range(MAX_GROUP_SIZE):
-        Gitxn[i].sender()
+    for i in range(pt.MAX_GROUP_SIZE):
+        pt.Gitxn[i].sender()
 
 
 def test_gitxn_expr_invalid():
     for f, e in [
         (
-            lambda: GitxnExpr(Int(1), TxnField.sender),
-            TealInputError,
+            lambda: pt.GitxnExpr(pt.Int(1), pt.TxnField.sender),
+            pt.TealInputError,
         ),
         (
-            lambda: GitxnExpr(1, TxnField.sender).__teal__(teal5Options),
-            TealInputError,
+            lambda: pt.GitxnExpr(1, pt.TxnField.sender).__teal__(teal5Options),
+            pt.TealInputError,
         ),
     ]:
         with pytest.raises(e):
@@ -42,26 +42,30 @@ def test_gitxn_expr_invalid():
 
 
 def test_gitxn_expr_valid():
-    GitxnExpr(1, TxnField.sender).__teal__(teal6Options)
+    pt.GitxnExpr(1, pt.TxnField.sender).__teal__(teal6Options)
 
 
 def test_gitxna_expr_invalid():
     for f, e in [
         (
-            lambda: GitxnaExpr("Invalid_type", TxnField.application_args, 1),
-            TealInputError,
+            lambda: pt.GitxnaExpr("Invalid_type", pt.TxnField.application_args, 1),
+            pt.TealInputError,
         ),
         (
-            lambda: GitxnaExpr(1, TxnField.application_args, "Invalid_type"),
-            TealInputError,
+            lambda: pt.GitxnaExpr(1, pt.TxnField.application_args, "Invalid_type"),
+            pt.TealInputError,
         ),
         (
-            lambda: GitxnaExpr(0, TxnField.application_args, Assert(Int(1))),
-            TealTypeError,
+            lambda: pt.GitxnaExpr(
+                0, pt.TxnField.application_args, pt.Assert(pt.Int(1))
+            ),
+            pt.TealTypeError,
         ),
         (
-            lambda: GitxnaExpr(0, TxnField.application_args, 0).__teal__(teal5Options),
-            TealInputError,
+            lambda: pt.GitxnaExpr(0, pt.TxnField.application_args, 0).__teal__(
+                teal5Options
+            ),
+            pt.TealInputError,
         ),
     ]:
         with pytest.raises(e):
@@ -72,8 +76,8 @@ def test_gitxna_valid():
     [
         e.__teal__(teal6Options)
         for e in [
-            GitxnaExpr(0, TxnField.application_args, 1),
-            GitxnaExpr(0, TxnField.application_args, Int(1)),
+            pt.GitxnaExpr(0, pt.TxnField.application_args, 1),
+            pt.GitxnaExpr(0, pt.TxnField.application_args, pt.Int(1)),
         ]
     ]
 
diff --git a/pyteal/ast/gload_test.py b/pyteal/ast/gload_test.py
index 882280e19..fe182af6a 100644
--- a/pyteal/ast/gload_test.py
+++ b/pyteal/ast/gload_test.py
@@ -1,36 +1,33 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import MAX_GROUP_SIZE, NUM_SLOTS, CompileOptions
-
-teal3Options = CompileOptions(version=3)
-teal4Options = CompileOptions(version=4)
-teal6Options = CompileOptions(version=6)
+teal3Options = pt.CompileOptions(version=3)
+teal4Options = pt.CompileOptions(version=4)
+teal6Options = pt.CompileOptions(version=6)
 
 
 def test_gload_teal_3():
-    with pytest.raises(TealInputError):
-        ImportScratchValue(0, 1).__teal__(teal3Options)
+    with pytest.raises(pt.TealInputError):
+        pt.ImportScratchValue(0, 1).__teal__(teal3Options)
 
-    with pytest.raises(TealInputError):
-        ImportScratchValue(Int(0), 1).__teal__(teal3Options)
+    with pytest.raises(pt.TealInputError):
+        pt.ImportScratchValue(pt.Int(0), 1).__teal__(teal3Options)
 
-    with pytest.raises(TealInputError):
-        ImportScratchValue(Int(0), Int(1)).__teal__(teal3Options)
+    with pytest.raises(pt.TealInputError):
+        pt.ImportScratchValue(pt.Int(0), pt.Int(1)).__teal__(teal3Options)
 
 
 def test_gload_teal_4():
-    with pytest.raises(TealInputError):
-        ImportScratchValue(Int(0), Int(2)).__teal__(teal4Options)
+    with pytest.raises(pt.TealInputError):
+        pt.ImportScratchValue(pt.Int(0), pt.Int(2)).__teal__(teal4Options)
 
 
 def test_gload():
-    expr = ImportScratchValue(0, 1)
-    assert expr.type_of() == TealType.anytype
+    expr = pt.ImportScratchValue(0, 1)
+    assert expr.type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock([TealOp(expr, Op.gload, 0, 1)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.gload, 0, 1)])
 
     actual, _ = expr.__teal__(teal4Options)
 
@@ -38,51 +35,57 @@ def test_gload():
 
 
 def test_gloads():
-    arg = Int(1)
-    expr = ImportScratchValue(arg, 0)
-    assert expr.type_of() == TealType.anytype
+    arg = pt.Int(1)
+    expr = pt.ImportScratchValue(arg, 0)
+    assert expr.type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 1), TealOp(expr, Op.gloads, 0)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 1), pt.TealOp(expr, pt.Op.gloads, 0)]
+    )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_gloadss():
-    txID = Int(1)
-    slotID = Int(0)
-    expr = ImportScratchValue(txID, slotID)
-    assert expr.type_of() == TealType.anytype
-
-    expected = TealSimpleBlock(
-        [TealOp(txID, Op.int, 1), TealOp(slotID, Op.int, 0), TealOp(expr, Op.gloadss)]
+    txID = pt.Int(1)
+    slotID = pt.Int(0)
+    expr = pt.ImportScratchValue(txID, slotID)
+    assert expr.type_of() == pt.TealType.anytype
+
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(txID, pt.Op.int, 1),
+            pt.TealOp(slotID, pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.gloadss),
+        ]
     )
 
     actual, _ = expr.__teal__(teal6Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_gload_invalid():
-    with pytest.raises(TealInputError):
-        ImportScratchValue(-1, 0)
+    with pytest.raises(pt.TealInputError):
+        pt.ImportScratchValue(-1, 0)
 
-    with pytest.raises(TealInputError):
-        ImportScratchValue(MAX_GROUP_SIZE, 0)
+    with pytest.raises(pt.TealInputError):
+        pt.ImportScratchValue(pt.MAX_GROUP_SIZE, 0)
 
-    with pytest.raises(TealInputError):
-        ImportScratchValue(0, -1)
+    with pytest.raises(pt.TealInputError):
+        pt.ImportScratchValue(0, -1)
 
-    with pytest.raises(TealInputError):
-        ImportScratchValue(0, NUM_SLOTS)
+    with pytest.raises(pt.TealInputError):
+        pt.ImportScratchValue(0, pt.NUM_SLOTS)
 
-    with pytest.raises(TealInputError):
-        ImportScratchValue(0, Int(0))
+    with pytest.raises(pt.TealInputError):
+        pt.ImportScratchValue(0, pt.Int(0))
 
-    with pytest.raises(TealTypeError):
-        ImportScratchValue(Bytes("AQID"), 0)  # byte encoding of [1, 2, 3]
+    with pytest.raises(pt.TealTypeError):
+        pt.ImportScratchValue(pt.Bytes("AQID"), 0)  # byte encoding of [1, 2, 3]
diff --git a/pyteal/ast/global_test.py b/pyteal/ast/global_test.py
index 969f042e8..4e72b3bd1 100644
--- a/pyteal/ast/global_test.py
+++ b/pyteal/ast/global_test.py
@@ -1,21 +1,18 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-teal2Options = CompileOptions(version=2)
-teal3Options = CompileOptions(version=3)
-teal5Options = CompileOptions(version=5)
-teal6Options = CompileOptions(version=6)
+teal2Options = pt.CompileOptions(version=2)
+teal3Options = pt.CompileOptions(version=3)
+teal5Options = pt.CompileOptions(version=5)
+teal6Options = pt.CompileOptions(version=6)
 
 
 def test_global_min_txn_fee():
-    expr = Global.min_txn_fee()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.min_txn_fee()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "MinTxnFee")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "MinTxnFee")])
 
     actual, _ = expr.__teal__(teal2Options)
 
@@ -23,10 +20,10 @@ def test_global_min_txn_fee():
 
 
 def test_global_min_balance():
-    expr = Global.min_balance()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.min_balance()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "MinBalance")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "MinBalance")])
 
     actual, _ = expr.__teal__(teal2Options)
 
@@ -34,10 +31,10 @@ def test_global_min_balance():
 
 
 def test_global_max_txn_life():
-    expr = Global.max_txn_life()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.max_txn_life()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "MaxTxnLife")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "MaxTxnLife")])
 
     actual, _ = expr.__teal__(teal2Options)
 
@@ -45,10 +42,10 @@ def test_global_max_txn_life():
 
 
 def test_global_zero_address():
-    expr = Global.zero_address()
-    assert expr.type_of() == TealType.bytes
+    expr = pt.Global.zero_address()
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "ZeroAddress")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "ZeroAddress")])
 
     actual, _ = expr.__teal__(teal2Options)
 
@@ -56,10 +53,10 @@ def test_global_zero_address():
 
 
 def test_global_group_size():
-    expr = Global.group_size()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.group_size()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "GroupSize")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "GroupSize")])
 
     actual, _ = expr.__teal__(teal2Options)
 
@@ -67,10 +64,10 @@ def test_global_group_size():
 
 
 def test_global_logic_sig_version():
-    expr = Global.logic_sig_version()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.logic_sig_version()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "LogicSigVersion")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "LogicSigVersion")])
 
     actual, _ = expr.__teal__(teal2Options)
 
@@ -78,10 +75,10 @@ def test_global_logic_sig_version():
 
 
 def test_global_round():
-    expr = Global.round()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.round()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "Round")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "Round")])
 
     actual, _ = expr.__teal__(teal2Options)
 
@@ -89,10 +86,10 @@ def test_global_round():
 
 
 def test_global_latest_timestamp():
-    expr = Global.latest_timestamp()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.latest_timestamp()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "LatestTimestamp")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "LatestTimestamp")])
 
     actual, _ = expr.__teal__(teal2Options)
 
@@ -100,10 +97,12 @@ def test_global_latest_timestamp():
 
 
 def test_global_current_application_id():
-    expr = Global.current_application_id()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.current_application_id()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "CurrentApplicationID")])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(expr, pt.Op.global_, "CurrentApplicationID")]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
 
@@ -111,84 +110,90 @@ def test_global_current_application_id():
 
 
 def test_global_creator_address():
-    expr = Global.creator_address()
-    assert expr.type_of() == TealType.bytes
+    expr = pt.Global.creator_address()
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "CreatorAddress")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "CreatorAddress")])
 
     actual, _ = expr.__teal__(teal3Options)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal2Options)
 
 
 def test_global_current_application_address():
-    expr = Global.current_application_address()
-    assert expr.type_of() == TealType.bytes
+    expr = pt.Global.current_application_address()
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "CurrentApplicationAddress")])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(expr, pt.Op.global_, "CurrentApplicationAddress")]
+    )
 
     actual, _ = expr.__teal__(teal5Options)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_global_group_id():
-    expr = Global.group_id()
-    assert expr.type_of() == TealType.bytes
+    expr = pt.Global.group_id()
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "GroupID")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "GroupID")])
 
     actual, _ = expr.__teal__(teal5Options)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal3Options)
 
 
 def test_global_opcode_budget():
-    expr = Global.opcode_budget()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.opcode_budget()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "OpcodeBudget")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.global_, "OpcodeBudget")])
 
     actual, _ = expr.__teal__(teal6Options)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal5Options)
 
 
 def test_global_caller_application_id():
-    expr = Global.caller_app_id()
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Global.caller_app_id()
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "CallerApplicationID")])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(expr, pt.Op.global_, "CallerApplicationID")]
+    )
 
     actual, _ = expr.__teal__(teal6Options)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal5Options)
 
 
 def test_global_caller_app_address():
-    expr = Global.caller_app_address()
-    assert expr.type_of() == TealType.bytes
+    expr = pt.Global.caller_app_address()
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(expr, Op.global_, "CallerApplicationAddress")])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(expr, pt.Op.global_, "CallerApplicationAddress")]
+    )
 
     actual, _ = expr.__teal__(teal6Options)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal5Options)
diff --git a/pyteal/ast/gtxn_test.py b/pyteal/ast/gtxn_test.py
index 9b895d100..9f48e5317 100644
--- a/pyteal/ast/gtxn_test.py
+++ b/pyteal/ast/gtxn_test.py
@@ -1,16 +1,16 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-teal6Options = CompileOptions(version=6)
+teal6Options = pt.CompileOptions(version=6)
 
 
 def test_gtxn_invalid():
     for f, e in [
-        (lambda: Gtxn[-1], TealInputError),
-        (lambda: Gtxn[MAX_GROUP_SIZE + 1], TealInputError),
-        (lambda: Gtxn[Pop(Int(0))], TealTypeError),
-        (lambda: Gtxn[Bytes("index")], TealTypeError),
+        (lambda: pt.Gtxn[-1], pt.TealInputError),
+        (lambda: pt.Gtxn[pt.MAX_GROUP_SIZE + 1], pt.TealInputError),
+        (lambda: pt.Gtxn[pt.Pop(pt.Int(0))], pt.TealTypeError),
+        (lambda: pt.Gtxn[pt.Bytes("index")], pt.TealTypeError),
     ]:
         with pytest.raises(e):
             f()
@@ -18,7 +18,10 @@ def test_gtxn_invalid():
 
 def test_gtxn_expr_invalid():
     for f, e in [
-        (lambda: GtxnExpr(Assert(Int(1)), TxnField.sender), TealTypeError),
+        (
+            lambda: pt.GtxnExpr(pt.Assert(pt.Int(1)), pt.TxnField.sender),
+            pt.TealTypeError,
+        ),
     ]:
         with pytest.raises(e):
             f()
@@ -28,18 +31,30 @@ def test_gtxn_expr_valid():
     [
         e.__teal__(teal6Options)
         for e in [
-            GtxnExpr(1, TxnField.sender),
-            GtxnExpr(Int(1), TxnField.sender),
+            pt.GtxnExpr(1, pt.TxnField.sender),
+            pt.GtxnExpr(pt.Int(1), pt.TxnField.sender),
         ]
     ]
 
 
 def test_gtxna_expr_invalid():
     for f, e in [
-        (lambda: GtxnaExpr("Invalid_type", TxnField.assets, 1), TealInputError),
-        (lambda: GtxnaExpr(1, TxnField.assets, "Invalid_type"), TealInputError),
-        (lambda: GtxnaExpr(Assert(Int(1)), TxnField.assets, 1), TealTypeError),
-        (lambda: GtxnaExpr(1, TxnField.assets, Assert(Int(1))), TealTypeError),
+        (
+            lambda: pt.GtxnaExpr("Invalid_type", pt.TxnField.assets, 1),
+            pt.TealInputError,
+        ),
+        (
+            lambda: pt.GtxnaExpr(1, pt.TxnField.assets, "Invalid_type"),
+            pt.TealInputError,
+        ),
+        (
+            lambda: pt.GtxnaExpr(pt.Assert(pt.Int(1)), pt.TxnField.assets, 1),
+            pt.TealTypeError,
+        ),
+        (
+            lambda: pt.GtxnaExpr(1, pt.TxnField.assets, pt.Assert(pt.Int(1))),
+            pt.TealTypeError,
+        ),
     ]:
         with pytest.raises(e):
             f()
@@ -49,8 +64,8 @@ def test_gtxna_expr_valid():
     [
         e.__teal__(teal6Options)
         for e in [
-            GtxnaExpr(1, TxnField.assets, 1),
-            GtxnaExpr(Int(1), TxnField.assets, Int(1)),
+            pt.GtxnaExpr(1, pt.TxnField.assets, 1),
+            pt.GtxnaExpr(pt.Int(1), pt.TxnField.assets, pt.Int(1)),
         ]
     ]
 
diff --git a/pyteal/ast/if_test.py b/pyteal/ast/if_test.py
index d174731f8..32d8f2f92 100644
--- a/pyteal/ast/if_test.py
+++ b/pyteal/ast/if_test.py
@@ -1,39 +1,38 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_if_has_return():
-    exprWithReturn = If(Int(1), Return(Int(1)), Return(Int(0)))
+    exprWithReturn = pt.If(pt.Int(1), pt.Return(pt.Int(1)), pt.Return(pt.Int(0)))
     assert exprWithReturn.has_return()
 
-    exprWithoutReturn = If(Int(1), Int(1), Int(0))
+    exprWithoutReturn = pt.If(pt.Int(1), pt.Int(1), pt.Int(0))
     assert not exprWithoutReturn.has_return()
 
-    exprSemiReturn = If(
-        Int(1), Return(Int(1)), App.globalPut(Bytes("key"), Bytes("value"))
+    exprSemiReturn = pt.If(
+        pt.Int(1),
+        pt.Return(pt.Int(1)),
+        pt.App.globalPut(pt.Bytes("key"), pt.Bytes("value")),
     )
     assert not exprSemiReturn.has_return()
 
 
 def test_if_int():
-    args = [Int(0), Int(1), Int(2)]
-    expr = If(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(0), pt.Int(1), pt.Int(2)]
+    expr = pt.If(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.uint64
 
     expected, _ = args[0].__teal__(options)
     thenBlock, _ = args[1].__teal__(options)
     elseBlock, _ = args[2].__teal__(options)
-    expectedBranch = TealConditionalBlock([])
+    expectedBranch = pt.TealConditionalBlock([])
     expectedBranch.setTrueBlock(thenBlock)
     expectedBranch.setFalseBlock(elseBlock)
     expected.setNextBlock(expectedBranch)
-    end = TealSimpleBlock([])
+    end = pt.TealSimpleBlock([])
     thenBlock.setNextBlock(end)
     elseBlock.setNextBlock(end)
 
@@ -43,18 +42,18 @@ def test_if_int():
 
 
 def test_if_bytes():
-    args = [Int(1), Txn.sender(), Txn.receiver()]
-    expr = If(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Int(1), pt.Txn.sender(), pt.Txn.receiver()]
+    expr = pt.If(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
     expected, _ = args[0].__teal__(options)
     thenBlock, _ = args[1].__teal__(options)
     elseBlock, _ = args[2].__teal__(options)
-    expectedBranch = TealConditionalBlock([])
+    expectedBranch = pt.TealConditionalBlock([])
     expectedBranch.setTrueBlock(thenBlock)
     expectedBranch.setFalseBlock(elseBlock)
     expected.setNextBlock(expectedBranch)
-    end = TealSimpleBlock([])
+    end = pt.TealSimpleBlock([])
     thenBlock.setNextBlock(end)
     elseBlock.setNextBlock(end)
 
@@ -64,18 +63,18 @@ def test_if_bytes():
 
 
 def test_if_none():
-    args = [Int(0), Pop(Txn.sender()), Pop(Txn.receiver())]
-    expr = If(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.none
+    args = [pt.Int(0), pt.Pop(pt.Txn.sender()), pt.Pop(pt.Txn.receiver())]
+    expr = pt.If(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.none
 
     expected, _ = args[0].__teal__(options)
     thenBlockStart, thenBlockEnd = args[1].__teal__(options)
     elseBlockStart, elseBlockEnd = args[2].__teal__(options)
-    expectedBranch = TealConditionalBlock([])
+    expectedBranch = pt.TealConditionalBlock([])
     expectedBranch.setTrueBlock(thenBlockStart)
     expectedBranch.setFalseBlock(elseBlockStart)
     expected.setNextBlock(expectedBranch)
-    end = TealSimpleBlock([])
+    end = pt.TealSimpleBlock([])
     thenBlockEnd.setNextBlock(end)
     elseBlockEnd.setNextBlock(end)
 
@@ -85,14 +84,14 @@ def test_if_none():
 
 
 def test_if_single():
-    args = [Int(1), Pop(Int(1))]
-    expr = If(args[0], args[1])
-    assert expr.type_of() == TealType.none
+    args = [pt.Int(1), pt.Pop(pt.Int(1))]
+    expr = pt.If(args[0], args[1])
+    assert expr.type_of() == pt.TealType.none
 
     expected, _ = args[0].__teal__(options)
     thenBlockStart, thenBlockEnd = args[1].__teal__(options)
-    end = TealSimpleBlock([])
-    expectedBranch = TealConditionalBlock([])
+    end = pt.TealSimpleBlock([])
+    expectedBranch = pt.TealConditionalBlock([])
     expectedBranch.setTrueBlock(thenBlockStart)
     expectedBranch.setFalseBlock(end)
     expected.setNextBlock(expectedBranch)
@@ -104,36 +103,36 @@ def test_if_single():
 
 
 def test_if_invalid():
-    with pytest.raises(TealTypeError):
-        If(Int(0), Txn.amount(), Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.If(pt.Int(0), pt.Txn.amount(), pt.Txn.sender())
 
-    with pytest.raises(TealTypeError):
-        If(Txn.sender(), Int(1), Int(0))
+    with pytest.raises(pt.TealTypeError):
+        pt.If(pt.Txn.sender(), pt.Int(1), pt.Int(0))
 
-    with pytest.raises(TealTypeError):
-        If(Int(0), Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.If(pt.Int(0), pt.Txn.sender())
 
-    with pytest.raises(TealTypeError):
-        If(Int(0), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.If(pt.Int(0), pt.Int(2))
 
-    with pytest.raises(TealCompileError):
-        expr = If(Int(0))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.If(pt.Int(0))
         expr.__teal__(options)
 
 
 def test_if_alt_int():
-    args = [Int(0), Int(1), Int(2)]
-    expr = If(args[0]).Then(args[1]).Else(args[2])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(0), pt.Int(1), pt.Int(2)]
+    expr = pt.If(args[0]).Then(args[1]).Else(args[2])
+    assert expr.type_of() == pt.TealType.uint64
 
     expected, _ = args[0].__teal__(options)
     thenBlock, _ = args[1].__teal__(options)
     elseBlock, _ = args[2].__teal__(options)
-    expectedBranch = TealConditionalBlock([])
+    expectedBranch = pt.TealConditionalBlock([])
     expectedBranch.setTrueBlock(thenBlock)
     expectedBranch.setFalseBlock(elseBlock)
     expected.setNextBlock(expectedBranch)
-    end = TealSimpleBlock([])
+    end = pt.TealSimpleBlock([])
     thenBlock.setNextBlock(end)
     elseBlock.setNextBlock(end)
 
@@ -143,18 +142,18 @@ def test_if_alt_int():
 
 
 def test_if_alt_bytes():
-    args = [Int(1), Txn.sender(), Txn.receiver()]
-    expr = If(args[0]).Then(args[1]).Else(args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Int(1), pt.Txn.sender(), pt.Txn.receiver()]
+    expr = pt.If(args[0]).Then(args[1]).Else(args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
     expected, _ = args[0].__teal__(options)
     thenBlock, _ = args[1].__teal__(options)
     elseBlock, _ = args[2].__teal__(options)
-    expectedBranch = TealConditionalBlock([])
+    expectedBranch = pt.TealConditionalBlock([])
     expectedBranch.setTrueBlock(thenBlock)
     expectedBranch.setFalseBlock(elseBlock)
     expected.setNextBlock(expectedBranch)
-    end = TealSimpleBlock([])
+    end = pt.TealSimpleBlock([])
     thenBlock.setNextBlock(end)
     elseBlock.setNextBlock(end)
 
@@ -164,18 +163,18 @@ def test_if_alt_bytes():
 
 
 def test_if_alt_none():
-    args = [Int(0), Pop(Txn.sender()), Pop(Txn.receiver())]
-    expr = If(args[0]).Then(args[1]).Else(args[2])
-    assert expr.type_of() == TealType.none
+    args = [pt.Int(0), pt.Pop(pt.Txn.sender()), pt.Pop(pt.Txn.receiver())]
+    expr = pt.If(args[0]).Then(args[1]).Else(args[2])
+    assert expr.type_of() == pt.TealType.none
 
     expected, _ = args[0].__teal__(options)
     thenBlockStart, thenBlockEnd = args[1].__teal__(options)
     elseBlockStart, elseBlockEnd = args[2].__teal__(options)
-    expectedBranch = TealConditionalBlock([])
+    expectedBranch = pt.TealConditionalBlock([])
     expectedBranch.setTrueBlock(thenBlockStart)
     expectedBranch.setFalseBlock(elseBlockStart)
     expected.setNextBlock(expectedBranch)
-    end = TealSimpleBlock([])
+    end = pt.TealSimpleBlock([])
     thenBlockEnd.setNextBlock(end)
     elseBlockEnd.setNextBlock(end)
 
@@ -185,19 +184,19 @@ def test_if_alt_none():
 
 
 def test_elseif_syntax():
-    args = [Int(0), Int(1), Int(2), Int(3), Int(4)]
-    expr = If(args[0]).Then(args[1]).ElseIf(args[2]).Then(args[3]).Else(args[4])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(0), pt.Int(1), pt.Int(2), pt.Int(3), pt.Int(4)]
+    expr = pt.If(args[0]).Then(args[1]).ElseIf(args[2]).Then(args[3]).Else(args[4])
+    assert expr.type_of() == pt.TealType.uint64
 
-    elseExpr = If(args[2]).Then(args[3]).Else(args[4])
+    elseExpr = pt.If(args[2]).Then(args[3]).Else(args[4])
     expected, _ = args[0].__teal__(options)
     thenBlock, _ = args[1].__teal__(options)
     elseStart, elseEnd = elseExpr.__teal__(options)
-    expectedBranch = TealConditionalBlock([])
+    expectedBranch = pt.TealConditionalBlock([])
     expectedBranch.setTrueBlock(thenBlock)
     expectedBranch.setFalseBlock(elseStart)
     expected.setNextBlock(expectedBranch)
-    end = TealSimpleBlock([])
+    end = pt.TealSimpleBlock([])
     thenBlock.setNextBlock(end)
     elseEnd.setNextBlock(end)
 
@@ -207,9 +206,9 @@ def test_elseif_syntax():
 
 
 def test_elseif_multiple():
-    args = [Int(0), Int(1), Int(2), Int(3), Int(4), Int(5), Int(6)]
+    args = [pt.Int(0), pt.Int(1), pt.Int(2), pt.Int(3), pt.Int(4), pt.Int(5), pt.Int(6)]
     expr = (
-        If(args[0])
+        pt.If(args[0])
         .Then(args[1])
         .ElseIf(args[2])
         .Then(args[3])
@@ -217,17 +216,17 @@ def test_elseif_multiple():
         .Then(args[5])
         .Else(args[6])
     )
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    elseIfExpr = If(args[2], args[3], If(args[4], args[5], args[6]))
+    elseIfExpr = pt.If(args[2], args[3], pt.If(args[4], args[5], args[6]))
     expected, _ = args[0].__teal__(options)
     thenBlock, _ = args[1].__teal__(options)
     elseStart, elseEnd = elseIfExpr.__teal__(options)
-    expectedBranch = TealConditionalBlock([])
+    expectedBranch = pt.TealConditionalBlock([])
     expectedBranch.setTrueBlock(thenBlock)
     expectedBranch.setFalseBlock(elseStart)
     expected.setNextBlock(expectedBranch)
-    end = TealSimpleBlock([])
+    end = pt.TealSimpleBlock([])
     thenBlock.setNextBlock(end)
     elseEnd.setNextBlock(end)
 
@@ -237,31 +236,31 @@ def test_elseif_multiple():
 
 
 def test_if_invalid_alt_syntax():
-    with pytest.raises(TealCompileError):
-        expr = If(Int(0)).ElseIf(Int(1))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.If(pt.Int(0)).ElseIf(pt.Int(1))
         expr.__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        expr = If(Int(0)).ElseIf(Int(1)).Then(Int(2))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.If(pt.Int(0)).ElseIf(pt.Int(1)).Then(pt.Int(2))
         expr.__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        expr = If(Int(0)).Then(Int(1)).ElseIf(Int(2))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.If(pt.Int(0)).Then(pt.Int(1)).ElseIf(pt.Int(2))
         expr.__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        expr = If(Int(0)).Then(Int(1)).ElseIf(Int(2))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.If(pt.Int(0)).Then(pt.Int(1)).ElseIf(pt.Int(2))
         expr.__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        expr = If(Int(0)).Else(Int(1))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.If(pt.Int(0)).Else(pt.Int(1))
         expr.__teal__(options)
 
-    with pytest.raises(TealInputError):
-        expr = If(Int(0)).Else(Int(1)).Then(Int(2))
+    with pytest.raises(pt.TealInputError):
+        expr = pt.If(pt.Int(0)).Else(pt.Int(1)).Then(pt.Int(2))
 
-    with pytest.raises(TealInputError):
-        expr = If(Int(0)).Else(Int(1)).Else(Int(2))
+    with pytest.raises(pt.TealInputError):
+        expr = pt.If(pt.Int(0)).Else(pt.Int(1)).Else(pt.Int(2))
 
-    with pytest.raises(TealInputError):
-        expr = If(Int(0), Pop(Int(1))).Else(Int(2))
+    with pytest.raises(pt.TealInputError):
+        expr = pt.If(pt.Int(0), pt.Pop(pt.Int(1))).Else(pt.Int(2))
diff --git a/pyteal/ast/int_test.py b/pyteal/ast/int_test.py
index e11a13da5..8b65033bc 100644
--- a/pyteal/ast/int_test.py
+++ b/pyteal/ast/int_test.py
@@ -1,21 +1,18 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_int():
     values = [0, 1, 8, 232323, 2**64 - 1]
 
     for value in values:
-        expr = Int(value)
-        assert expr.type_of() == TealType.uint64
+        expr = pt.Int(value)
+        assert expr.type_of() == pt.TealType.uint64
 
-        expected = TealSimpleBlock([TealOp(expr, Op.int, value)])
+        expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.int, value)])
 
         actual, _ = expr.__teal__(options)
 
@@ -23,24 +20,24 @@ def test_int():
 
 
 def test_int_invalid():
-    with pytest.raises(TealInputError):
-        Int(6.7)
+    with pytest.raises(pt.TealInputError):
+        pt.Int(6.7)
 
-    with pytest.raises(TealInputError):
-        Int(-1)
+    with pytest.raises(pt.TealInputError):
+        pt.Int(-1)
 
-    with pytest.raises(TealInputError):
-        Int(2**64)
+    with pytest.raises(pt.TealInputError):
+        pt.Int(2**64)
 
-    with pytest.raises(TealInputError):
-        Int("0")
+    with pytest.raises(pt.TealInputError):
+        pt.Int("0")
 
 
 def test_enum_int():
-    expr = EnumInt("OptIn")
-    assert expr.type_of() == TealType.uint64
+    expr = pt.EnumInt("OptIn")
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.int, "OptIn")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.int, "OptIn")])
 
     actual, _ = expr.__teal__(options)
 
diff --git a/pyteal/ast/itxn_test.py b/pyteal/ast/itxn_test.py
index 7f5c06e5a..53b65d2d4 100644
--- a/pyteal/ast/itxn_test.py
+++ b/pyteal/ast/itxn_test.py
@@ -1,131 +1,136 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 from ..types import types_match
 
-# this is not necessary but mypy complains if it's not included
-from .. import MAX_GROUP_SIZE, CompileOptions
-
-teal4Options = CompileOptions(version=4)
-teal5Options = CompileOptions(version=5)
-teal6Options = CompileOptions(version=6)
+teal4Options = pt.CompileOptions(version=4)
+teal5Options = pt.CompileOptions(version=5)
+teal6Options = pt.CompileOptions(version=6)
 
 
 def test_InnerTxnBuilder_Begin():
-    expr = InnerTxnBuilder.Begin()
-    assert expr.type_of() == TealType.none
+    expr = pt.InnerTxnBuilder.Begin()
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
-    expected = TealSimpleBlock([TealOp(expr, Op.itxn_begin)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.itxn_begin)])
 
     actual, _ = expr.__teal__(teal5Options)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal4Options)
 
 
 def test_InnerTxnBuilder_Submit():
-    expr = InnerTxnBuilder.Submit()
-    assert expr.type_of() == TealType.none
+    expr = pt.InnerTxnBuilder.Submit()
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
-    expected = TealSimpleBlock([TealOp(expr, Op.itxn_submit)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.itxn_submit)])
 
     actual, _ = expr.__teal__(teal5Options)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal4Options)
 
 
 def test_InnerTxnBuilder_Next():
-    expr = InnerTxnBuilder.Next()
-    assert expr.type_of() == TealType.none
+    expr = pt.InnerTxnBuilder.Next()
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
-    expected = TealSimpleBlock([TealOp(expr, Op.itxn_next)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.itxn_next)])
 
     actual, _ = expr.__teal__(teal6Options)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal5Options)
 
 
 def test_InnerTxnBuilder_SetField():
-    for field in TxnField:
+    for field in pt.TxnField:
         if field.is_array:
-            with pytest.raises(TealInputError):
-                InnerTxnBuilder.SetField(field, Int(0))
+            with pytest.raises(pt.TealInputError):
+                pt.InnerTxnBuilder.SetField(field, pt.Int(0))
             continue
 
         for value, opArgs in (
-            (Int(0), (Op.int, 0)),
-            (Bytes("value"), (Op.byte, '"value"')),
+            (pt.Int(0), (pt.Op.int, 0)),
+            (pt.Bytes("value"), (pt.Op.byte, '"value"')),
         ):
-            assert field.type_of() in (TealType.uint64, TealType.bytes)
+            assert field.type_of() in (pt.TealType.uint64, pt.TealType.bytes)
 
             if not types_match(field.type_of(), value.type_of()):
-                with pytest.raises(TealTypeError):
-                    InnerTxnBuilder.SetField(field, value)
+                with pytest.raises(pt.TealTypeError):
+                    pt.InnerTxnBuilder.SetField(field, value)
                 continue
 
-            expr = InnerTxnBuilder.SetField(field, value)
-            assert expr.type_of() == TealType.none
+            expr = pt.InnerTxnBuilder.SetField(field, value)
+            assert expr.type_of() == pt.TealType.none
             assert not expr.has_return()
 
-            expected = TealSimpleBlock(
-                [TealOp(value, *opArgs), TealOp(expr, Op.itxn_field, field.arg_name)]
+            expected = pt.TealSimpleBlock(
+                [
+                    pt.TealOp(value, *opArgs),
+                    pt.TealOp(expr, pt.Op.itxn_field, field.arg_name),
+                ]
             )
 
             actual, _ = expr.__teal__(teal5Options)
             actual.addIncoming()
-            actual = TealBlock.NormalizeBlocks(actual)
+            actual = pt.TealBlock.NormalizeBlocks(actual)
 
             assert actual == expected
 
-            with pytest.raises(TealInputError):
+            with pytest.raises(pt.TealInputError):
                 expr.__teal__(teal4Options)
 
 
 def test_InnerTxnBuilder_SetFields():
     cases = (
-        ({}, Seq()),
-        ({TxnField.amount: Int(5)}, InnerTxnBuilder.SetField(TxnField.amount, Int(5))),
+        ({}, pt.Seq()),
+        (
+            {pt.TxnField.amount: pt.Int(5)},
+            pt.InnerTxnBuilder.SetField(pt.TxnField.amount, pt.Int(5)),
+        ),
         (
             {
-                TxnField.type_enum: TxnType.Payment,
-                TxnField.close_remainder_to: Txn.sender(),
+                pt.TxnField.type_enum: pt.TxnType.Payment,
+                pt.TxnField.close_remainder_to: pt.Txn.sender(),
             },
-            Seq(
-                InnerTxnBuilder.SetField(TxnField.type_enum, TxnType.Payment),
-                InnerTxnBuilder.SetField(TxnField.close_remainder_to, Txn.sender()),
+            pt.Seq(
+                pt.InnerTxnBuilder.SetField(pt.TxnField.type_enum, pt.TxnType.Payment),
+                pt.InnerTxnBuilder.SetField(
+                    pt.TxnField.close_remainder_to, pt.Txn.sender()
+                ),
             ),
         ),
     )
 
     for fields, expectedExpr in cases:
-        expr = InnerTxnBuilder.SetFields(fields)
-        assert expr.type_of() == TealType.none
+        expr = pt.InnerTxnBuilder.SetFields(fields)
+        assert expr.type_of() == pt.TealType.none
         assert not expr.has_return()
 
         expected, _ = expectedExpr.__teal__(teal5Options)
         expected.addIncoming()
-        expected = TealBlock.NormalizeBlocks(expected)
+        expected = pt.TealBlock.NormalizeBlocks(expected)
 
         actual, _ = expr.__teal__(teal5Options)
         actual.addIncoming()
-        actual = TealBlock.NormalizeBlocks(actual)
+        actual = pt.TealBlock.NormalizeBlocks(actual)
 
-        with TealComponent.Context.ignoreExprEquality():
+        with pt.TealComponent.Context.ignoreExprEquality():
             assert actual == expected
 
         if len(fields) != 0:
-            with pytest.raises(TealInputError):
+            with pytest.raises(pt.TealInputError):
                 expr.__teal__(teal4Options)
 
 
diff --git a/pyteal/ast/maybe_test.py b/pyteal/ast/maybe_test.py
index 53daf7977..fa57ba5ca 100644
--- a/pyteal/ast/maybe_test.py
+++ b/pyteal/ast/maybe_test.py
@@ -1,52 +1,47 @@
-import pytest
+import pyteal as pt
 
-from .. import *
-
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_maybe_value():
     ops = (
-        Op.app_global_get_ex,
-        Op.app_local_get_ex,
-        Op.asset_holding_get,
-        Op.asset_params_get,
+        pt.Op.app_global_get_ex,
+        pt.Op.app_local_get_ex,
+        pt.Op.asset_holding_get,
+        pt.Op.asset_params_get,
     )
-    types = (TealType.uint64, TealType.bytes, TealType.anytype)
+    types = (pt.TealType.uint64, pt.TealType.bytes, pt.TealType.anytype)
     immedate_argv = ([], ["AssetFrozen"])
-    argv = ([], [Int(0)], [Int(1), Int(2)])
+    argv = ([], [pt.Int(0)], [pt.Int(1), pt.Int(2)])
 
     for op in ops:
         for type in types:
             for iargs in immedate_argv:
                 for args in argv:
-                    expr = MaybeValue(op, type, immediate_args=iargs, args=args)
+                    expr = pt.MaybeValue(op, type, immediate_args=iargs, args=args)
 
                     assert expr.slotOk != expr.slotValue
                     assert expr.output_slots == [expr.slotValue, expr.slotOk]
 
-                    assert expr.hasValue().type_of() == TealType.uint64
-                    with TealComponent.Context.ignoreExprEquality():
-                        assert expr.hasValue().__teal__(options) == ScratchLoad(
+                    assert expr.hasValue().type_of() == pt.TealType.uint64
+                    with pt.TealComponent.Context.ignoreExprEquality():
+                        assert expr.hasValue().__teal__(options) == pt.ScratchLoad(
                             expr.slotOk
                         ).__teal__(options)
 
                     assert expr.value().type_of() == type
-                    with TealComponent.Context.ignoreExprEquality():
-                        assert expr.value().__teal__(options) == ScratchLoad(
+                    with pt.TealComponent.Context.ignoreExprEquality():
+                        assert expr.value().__teal__(options) == pt.ScratchLoad(
                             expr.slotValue
                         ).__teal__(options)
 
-                    assert expr.type_of() == TealType.none
+                    assert expr.type_of() == pt.TealType.none
 
-                    expected_call = TealSimpleBlock(
+                    expected_call = pt.TealSimpleBlock(
                         [
-                            TealOp(expr, op, *iargs),
-                            TealOp(None, Op.store, expr.slotOk),
-                            TealOp(None, Op.store, expr.slotValue),
+                            pt.TealOp(expr, op, *iargs),
+                            pt.TealOp(None, pt.Op.store, expr.slotOk),
+                            pt.TealOp(None, pt.Op.store, expr.slotValue),
                         ]
                     )
 
@@ -62,11 +57,11 @@ def test_maybe_value():
                         after_arg_2.setNextBlock(expected_call)
 
                     expected.addIncoming()
-                    expected = TealBlock.NormalizeBlocks(expected)
+                    expected = pt.TealBlock.NormalizeBlocks(expected)
 
                     actual, _ = expr.__teal__(options)
                     actual.addIncoming()
-                    actual = TealBlock.NormalizeBlocks(actual)
+                    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-                    with TealComponent.Context.ignoreExprEquality():
+                    with pt.TealComponent.Context.ignoreExprEquality():
                         assert actual == expected
diff --git a/pyteal/ast/methodsig_test.py b/pyteal/ast/methodsig_test.py
index 6a941ea27..bec9d2cac 100644
--- a/pyteal/ast/methodsig_test.py
+++ b/pyteal/ast/methodsig_test.py
@@ -2,26 +2,26 @@
 
 from pyteal.ast.methodsig import MethodSignature
 
-from .. import *
+import pyteal as pt
 
 
 def test_method():
     expr = MethodSignature("add(uint64,uint64)uint64")
-    assert expr.type_of() == TealType.bytes
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
-        [TealOp(expr, Op.method_signature, '"add(uint64,uint64)uint64"')]
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(expr, pt.Op.method_signature, '"add(uint64,uint64)uint64"')]
     )
-    actual, _ = expr.__teal__(CompileOptions())
+    actual, _ = expr.__teal__(pt.CompileOptions())
     assert expected == actual
 
 
 def test_method_invalid():
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         MethodSignature(114514)
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         MethodSignature(['"m0()void"', '"m1()uint64"'])
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         MethodSignature("")
diff --git a/pyteal/ast/multi_test.py b/pyteal/ast/multi_test.py
index b710a027a..08c1c4093 100644
--- a/pyteal/ast/multi_test.py
+++ b/pyteal/ast/multi_test.py
@@ -1,48 +1,50 @@
 from typing import List
 
-from .. import *
+import pyteal as pt
 
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
-def __test_single(expr: MultiValue):
+def __test_single(expr: pt.MultiValue):
     assert expr.output_slots[0] != expr.output_slots[1]
 
-    with TealComponent.Context.ignoreExprEquality():
-        assert expr.output_slots[0].load().__teal__(options) == ScratchLoad(
+    with pt.TealComponent.Context.ignoreExprEquality():
+        assert expr.output_slots[0].load().__teal__(options) == pt.ScratchLoad(
             expr.output_slots[0]
         ).__teal__(options)
 
-    with TealComponent.Context.ignoreExprEquality():
-        assert expr.output_slots[1].load().__teal__(options) == ScratchLoad(
+    with pt.TealComponent.Context.ignoreExprEquality():
+        assert expr.output_slots[1].load().__teal__(options) == pt.ScratchLoad(
             expr.output_slots[1]
         ).__teal__(options)
 
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
 
 
-def __test_single_conditional(expr: MultiValue, op, args: List[Expr], iargs, reducer):
+def __test_single_conditional(
+    expr: pt.MultiValue, op, args: List[pt.Expr], iargs, reducer
+):
     __test_single(expr)
 
-    expected_call = TealSimpleBlock(
+    expected_call = pt.TealSimpleBlock(
         [
-            TealOp(expr, op, *iargs),
-            TealOp(expr.output_slots[1].store(), Op.store, expr.output_slots[1]),
-            TealOp(expr.output_slots[0].store(), Op.store, expr.output_slots[0]),
+            pt.TealOp(expr, op, *iargs),
+            pt.TealOp(expr.output_slots[1].store(), pt.Op.store, expr.output_slots[1]),
+            pt.TealOp(expr.output_slots[0].store(), pt.Op.store, expr.output_slots[0]),
         ]
     )
 
     ifExpr = (
-        If(expr.output_slots[1].load())
+        pt.If(expr.output_slots[1].load())
         .Then(expr.output_slots[0].load())
-        .Else(Bytes("None"))
+        .Else(pt.Bytes("None"))
     )
     ifBlockStart, _ = ifExpr.__teal__(options)
 
     expected_call.setNextBlock(ifBlockStart)
 
     if len(args) == 0:
-        expected: TealBlock = expected_call
+        expected: pt.TealBlock = expected_call
     elif len(args) == 1:
         expected, after_arg = args[0].__teal__(options)
         after_arg.setNextBlock(expected_call)
@@ -53,34 +55,36 @@ def __test_single_conditional(expr: MultiValue, op, args: List[Expr], iargs, red
         after_arg_2.setNextBlock(expected_call)
 
     expected.addIncoming()
-    expected = TealBlock.NormalizeBlocks(expected)
+    expected = pt.TealBlock.NormalizeBlocks(expected)
 
     actual, _ = expr.outputReducer(reducer).__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
-def __test_single_assert(expr: MultiValue, op, args: List[Expr], iargs, reducer):
+def __test_single_assert(expr: pt.MultiValue, op, args: List[pt.Expr], iargs, reducer):
     __test_single(expr)
 
-    expected_call = TealSimpleBlock(
+    expected_call = pt.TealSimpleBlock(
         [
-            TealOp(expr, op, *iargs),
-            TealOp(expr.output_slots[1].store(), Op.store, expr.output_slots[1]),
-            TealOp(expr.output_slots[0].store(), Op.store, expr.output_slots[0]),
+            pt.TealOp(expr, op, *iargs),
+            pt.TealOp(expr.output_slots[1].store(), pt.Op.store, expr.output_slots[1]),
+            pt.TealOp(expr.output_slots[0].store(), pt.Op.store, expr.output_slots[0]),
         ]
     )
 
-    assertExpr = Seq(Assert(expr.output_slots[1].load()), expr.output_slots[0].load())
+    assertExpr = pt.Seq(
+        pt.Assert(expr.output_slots[1].load()), expr.output_slots[0].load()
+    )
     assertBlockStart, _ = assertExpr.__teal__(options)
 
     expected_call.setNextBlock(assertBlockStart)
 
     if len(args) == 0:
-        expected: TealBlock = expected_call
+        expected: pt.TealBlock = expected_call
     elif len(args) == 1:
         expected, after_arg = args[0].__teal__(options)
         after_arg.setNextBlock(expected_call)
@@ -91,30 +95,30 @@ def __test_single_assert(expr: MultiValue, op, args: List[Expr], iargs, reducer)
         after_arg_2.setNextBlock(expected_call)
 
     expected.addIncoming()
-    expected = TealBlock.NormalizeBlocks(expected)
+    expected = pt.TealBlock.NormalizeBlocks(expected)
 
     actual, _ = expr.outputReducer(reducer).__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def __test_single_with_vars(
-    expr: MultiValue, op, args: List[Expr], iargs, var1, var2, reducer
+    expr: pt.MultiValue, op, args: List[pt.Expr], iargs, var1, var2, reducer
 ):
     __test_single(expr)
 
-    expected_call = TealSimpleBlock(
+    expected_call = pt.TealSimpleBlock(
         [
-            TealOp(expr, op, *iargs),
-            TealOp(expr.output_slots[1].store(), Op.store, expr.output_slots[1]),
-            TealOp(expr.output_slots[0].store(), Op.store, expr.output_slots[0]),
+            pt.TealOp(expr, op, *iargs),
+            pt.TealOp(expr.output_slots[1].store(), pt.Op.store, expr.output_slots[1]),
+            pt.TealOp(expr.output_slots[0].store(), pt.Op.store, expr.output_slots[0]),
         ]
     )
 
-    varExpr = Seq(
+    varExpr = pt.Seq(
         var1.store(expr.output_slots[1].load()), var2.store(expr.output_slots[0].load())
     )
     varBlockStart, _ = varExpr.__teal__(options)
@@ -122,7 +126,7 @@ def __test_single_with_vars(
     expected_call.setNextBlock(varBlockStart)
 
     if len(args) == 0:
-        expected: TealBlock = expected_call
+        expected: pt.TealBlock = expected_call
     elif len(args) == 1:
         expected, after_arg = args[0].__teal__(options)
         after_arg.setNextBlock(expected_call)
@@ -133,54 +137,56 @@ def __test_single_with_vars(
         after_arg_2.setNextBlock(expected_call)
 
     expected.addIncoming()
-    expected = TealBlock.NormalizeBlocks(expected)
+    expected = pt.TealBlock.NormalizeBlocks(expected)
 
     actual, _ = expr.outputReducer(reducer).__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_multi_value():
     ops = (
-        Op.app_global_get_ex,
-        Op.app_local_get_ex,
-        Op.asset_holding_get,
-        Op.asset_params_get,
+        pt.Op.app_global_get_ex,
+        pt.Op.app_local_get_ex,
+        pt.Op.asset_holding_get,
+        pt.Op.asset_params_get,
     )
-    types = (TealType.uint64, TealType.bytes, TealType.anytype)
+    types = (pt.TealType.uint64, pt.TealType.bytes, pt.TealType.anytype)
     immedate_argv = ([], ["AssetFrozen"])
-    argv = ([], [Int(0)], [Int(1), Int(2)])
+    argv = ([], [pt.Int(0)], [pt.Int(1), pt.Int(2)])
 
     for op in ops:
         for type in types:
             for iargs in immedate_argv:
                 for args in argv:
                     reducer = (
-                        lambda value, hasValue: If(hasValue)
+                        lambda value, hasValue: pt.If(hasValue)
                         .Then(value)
-                        .Else(Bytes("None"))
+                        .Else(pt.Bytes("None"))
                     )
-                    expr = MultiValue(
-                        op, [type, TealType.uint64], immediate_args=iargs, args=args
+                    expr = pt.MultiValue(
+                        op, [type, pt.TealType.uint64], immediate_args=iargs, args=args
                     )
                     __test_single_conditional(expr, op, args, iargs, reducer)
 
-                    reducer = lambda value, hasValue: Seq(Assert(hasValue), value)
-                    expr = MultiValue(
-                        op, [type, TealType.uint64], immediate_args=iargs, args=args
+                    reducer = lambda value, hasValue: pt.Seq(  # noqa: E731
+                        pt.Assert(hasValue), value
+                    )
+                    expr = pt.MultiValue(
+                        op, [type, pt.TealType.uint64], immediate_args=iargs, args=args
                     )
                     __test_single_assert(expr, op, args, iargs, reducer)
 
-                    hasValueVar = ScratchVar(TealType.uint64)
-                    valueVar = ScratchVar(type)
-                    reducer = lambda value, hasValue: Seq(
+                    hasValueVar = pt.ScratchVar(pt.TealType.uint64)
+                    valueVar = pt.ScratchVar(type)
+                    reducer = lambda value, hasValue: pt.Seq(  # noqa: E731
                         hasValueVar.store(hasValue), valueVar.store(value)
                     )
-                    expr = MultiValue(
-                        op, [type, TealType.uint64], immediate_args=iargs, args=args
+                    expr = pt.MultiValue(
+                        op, [type, pt.TealType.uint64], immediate_args=iargs, args=args
                     )
                     __test_single_with_vars(
                         expr, op, args, iargs, hasValueVar, valueVar, reducer
diff --git a/pyteal/ast/naryexpr_test.py b/pyteal/ast/naryexpr_test.py
index 674c6d119..c9b740175 100644
--- a/pyteal/ast/naryexpr_test.py
+++ b/pyteal/ast/naryexpr_test.py
@@ -1,19 +1,16 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_and_one():
-    arg = Int(1)
-    expr = And(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.And(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 1)])
+    expected = pt.TealSimpleBlock([pt.TealOp(arg, pt.Op.int, 1)])
 
     actual, _ = expr.__teal__(options)
 
@@ -21,87 +18,87 @@ def test_and_one():
 
 
 def test_and_two():
-    args = [Int(1), Int(2)]
-    expr = And(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(1), pt.Int(2)]
+    expr = pt.And(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 2),
-            TealOp(expr, Op.logic_and),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(expr, pt.Op.logic_and),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_and_three():
-    args = [Int(1), Int(2), Int(3)]
-    expr = And(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(1), pt.Int(2), pt.Int(3)]
+    expr = pt.And(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 2),
-            TealOp(expr, Op.logic_and),
-            TealOp(args[2], Op.int, 3),
-            TealOp(expr, Op.logic_and),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(expr, pt.Op.logic_and),
+            pt.TealOp(args[2], pt.Op.int, 3),
+            pt.TealOp(expr, pt.Op.logic_and),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_and_overload():
-    args = [Int(1), Int(2)]
+    args = [pt.Int(1), pt.Int(2)]
     expr = args[0].And(args[1])
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 2),
-            TealOp(expr, Op.logic_and),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(expr, pt.Op.logic_and),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_and_invalid():
-    with pytest.raises(TealInputError):
-        And()
+    with pytest.raises(pt.TealInputError):
+        pt.And()
 
-    with pytest.raises(TealTypeError):
-        And(Int(1), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.And(pt.Int(1), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        And(Txn.receiver(), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.And(pt.Txn.receiver(), pt.Int(1))
 
-    with pytest.raises(TealTypeError):
-        And(Txn.receiver(), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.And(pt.Txn.receiver(), pt.Txn.receiver())
 
 
 def test_or_one():
-    arg = Int(1)
-    expr = Or(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.Or(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 1)])
+    expected = pt.TealSimpleBlock([pt.TealOp(arg, pt.Op.int, 1)])
 
     actual, _ = expr.__teal__(options)
 
@@ -109,87 +106,87 @@ def test_or_one():
 
 
 def test_or_two():
-    args = [Int(1), Int(0)]
-    expr = Or(args[0], args[1])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(1), pt.Int(0)]
+    expr = pt.Or(args[0], args[1])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 0),
-            TealOp(expr, Op.logic_or),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.logic_or),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_or_three():
-    args = [Int(0), Int(1), Int(2)]
-    expr = Or(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(0), pt.Int(1), pt.Int(2)]
+    expr = pt.Or(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 0),
-            TealOp(args[1], Op.int, 1),
-            TealOp(expr, Op.logic_or),
-            TealOp(args[2], Op.int, 2),
-            TealOp(expr, Op.logic_or),
+            pt.TealOp(args[0], pt.Op.int, 0),
+            pt.TealOp(args[1], pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.logic_or),
+            pt.TealOp(args[2], pt.Op.int, 2),
+            pt.TealOp(expr, pt.Op.logic_or),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_or_overload():
-    args = [Int(1), Int(0)]
+    args = [pt.Int(1), pt.Int(0)]
     expr = args[0].Or(args[1])
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 1),
-            TealOp(args[1], Op.int, 0),
-            TealOp(expr, Op.logic_or),
+            pt.TealOp(args[0], pt.Op.int, 1),
+            pt.TealOp(args[1], pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.logic_or),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_or_invalid():
-    with pytest.raises(TealInputError):
-        Or()
+    with pytest.raises(pt.TealInputError):
+        pt.Or()
 
-    with pytest.raises(TealTypeError):
-        Or(Int(1), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Or(pt.Int(1), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Or(Txn.receiver(), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Or(pt.Txn.receiver(), pt.Int(1))
 
-    with pytest.raises(TealTypeError):
-        Or(Txn.receiver(), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Or(pt.Txn.receiver(), pt.Txn.receiver())
 
 
 def test_concat_one():
-    arg = Bytes("a")
-    expr = Concat(arg)
-    assert expr.type_of() == TealType.bytes
+    arg = pt.Bytes("a")
+    expr = pt.Concat(arg)
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(arg, Op.byte, '"a"')])
+    expected = pt.TealSimpleBlock([pt.TealOp(arg, pt.Op.byte, '"a"')])
 
     actual, _ = expr.__teal__(options)
 
@@ -197,56 +194,56 @@ def test_concat_one():
 
 
 def test_concat_two():
-    args = [Bytes("a"), Bytes("b")]
-    expr = Concat(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("a"), pt.Bytes("b")]
+    expr = pt.Concat(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"a"'),
-            TealOp(args[1], Op.byte, '"b"'),
-            TealOp(expr, Op.concat),
+            pt.TealOp(args[0], pt.Op.byte, '"a"'),
+            pt.TealOp(args[1], pt.Op.byte, '"b"'),
+            pt.TealOp(expr, pt.Op.concat),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_concat_three():
-    args = [Bytes("a"), Bytes("b"), Bytes("c")]
-    expr = Concat(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("a"), pt.Bytes("b"), pt.Bytes("c")]
+    expr = pt.Concat(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"a"'),
-            TealOp(args[1], Op.byte, '"b"'),
-            TealOp(expr, Op.concat),
-            TealOp(args[2], Op.byte, '"c"'),
-            TealOp(expr, Op.concat),
+            pt.TealOp(args[0], pt.Op.byte, '"a"'),
+            pt.TealOp(args[1], pt.Op.byte, '"b"'),
+            pt.TealOp(expr, pt.Op.concat),
+            pt.TealOp(args[2], pt.Op.byte, '"c"'),
+            pt.TealOp(expr, pt.Op.concat),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_concat_invalid():
-    with pytest.raises(TealInputError):
-        Concat()
+    with pytest.raises(pt.TealInputError):
+        pt.Concat()
 
-    with pytest.raises(TealTypeError):
-        Concat(Int(1), Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Concat(pt.Int(1), pt.Txn.receiver())
 
-    with pytest.raises(TealTypeError):
-        Concat(Txn.receiver(), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Concat(pt.Txn.receiver(), pt.Int(1))
 
-    with pytest.raises(TealTypeError):
-        Concat(Int(1), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Concat(pt.Int(1), pt.Int(2))
diff --git a/pyteal/ast/nonce_test.py b/pyteal/ast/nonce_test.py
index f5f7c16f7..21d165c02 100644
--- a/pyteal/ast/nonce_test.py
+++ b/pyteal/ast/nonce_test.py
@@ -1,48 +1,47 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_nonce_has_return():
-    exprWithReturn = Nonce(
+    exprWithReturn = pt.Nonce(
         "base32",
         "7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M",
-        Return(Int(1)),
+        pt.Return(pt.Int(1)),
     )
     assert exprWithReturn.has_return()
 
-    exprWithoutReturn = Nonce(
-        "base32", "7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M", Int(1)
+    exprWithoutReturn = pt.Nonce(
+        "base32",
+        "7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M",
+        pt.Int(1),
     )
     assert not exprWithoutReturn.has_return()
 
 
 def test_nonce_base32():
-    arg = Int(1)
-    expr = Nonce(
+    arg = pt.Int(1)
+    expr = pt.Nonce(
         "base32", "7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M", arg
     )
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     # copying expr from actual.ops[0] and actual.ops[1] because they can't be determined from outside code.
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(
+            pt.TealOp(
                 actual.ops[0].expr,
-                Op.byte,
+                pt.Op.byte,
                 "base32(7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M)",
             ),
-            TealOp(actual.ops[1].expr, Op.pop),
-            TealOp(arg, Op.int, 1),
+            pt.TealOp(actual.ops[1].expr, pt.Op.pop),
+            pt.TealOp(arg, pt.Op.int, 1),
         ]
     )
 
@@ -50,20 +49,20 @@ def test_nonce_base32():
 
 
 def test_nonce_base32_empty():
-    arg = Int(1)
-    expr = Nonce("base32", "", arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.Nonce("base32", "", arg)
+    assert expr.type_of() == pt.TealType.uint64
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     # copying expr from actual.ops[0] and actual.ops[1] because they can't be determined from outside code.
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(actual.ops[0].expr, Op.byte, "base32()"),
-            TealOp(actual.ops[1].expr, Op.pop),
-            TealOp(arg, Op.int, 1),
+            pt.TealOp(actual.ops[0].expr, pt.Op.byte, "base32()"),
+            pt.TealOp(actual.ops[1].expr, pt.Op.pop),
+            pt.TealOp(arg, pt.Op.int, 1),
         ]
     )
 
@@ -71,20 +70,20 @@ def test_nonce_base32_empty():
 
 
 def test_nonce_base64():
-    arg = Txn.sender()
-    expr = Nonce("base64", "Zm9vYmE=", arg)
-    assert expr.type_of() == TealType.bytes
+    arg = pt.Txn.sender()
+    expr = pt.Nonce("base64", "Zm9vYmE=", arg)
+    assert expr.type_of() == pt.TealType.bytes
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     # copying expr from actual.ops[0] and actual.ops[1] because they can't be determined from outside code.
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(actual.ops[0].expr, Op.byte, "base64(Zm9vYmE=)"),
-            TealOp(actual.ops[1].expr, Op.pop),
-            TealOp(arg, Op.txn, "Sender"),
+            pt.TealOp(actual.ops[0].expr, pt.Op.byte, "base64(Zm9vYmE=)"),
+            pt.TealOp(actual.ops[1].expr, pt.Op.pop),
+            pt.TealOp(arg, pt.Op.txn, "Sender"),
         ]
     )
 
@@ -92,20 +91,20 @@ def test_nonce_base64():
 
 
 def test_nonce_base64_empty():
-    arg = Int(1)
-    expr = Nonce("base64", "", arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.Nonce("base64", "", arg)
+    assert expr.type_of() == pt.TealType.uint64
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     # copying expr from actual.ops[0] and actual.ops[1] because they can't be determined from outside code.
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(actual.ops[0].expr, Op.byte, "base64()"),
-            TealOp(actual.ops[1].expr, Op.pop),
-            TealOp(arg, Op.int, 1),
+            pt.TealOp(actual.ops[0].expr, pt.Op.byte, "base64()"),
+            pt.TealOp(actual.ops[1].expr, pt.Op.pop),
+            pt.TealOp(arg, pt.Op.int, 1),
         ]
     )
 
@@ -113,20 +112,20 @@ def test_nonce_base64_empty():
 
 
 def test_nonce_base16():
-    arg = Int(1)
-    expr = Nonce("base16", "A21212EF", arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.Nonce("base16", "A21212EF", arg)
+    assert expr.type_of() == pt.TealType.uint64
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     # copying expr from actual.ops[0] and actual.ops[1] because they can't be determined from outside code.
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(actual.ops[0].expr, Op.byte, "0xA21212EF"),
-            TealOp(actual.ops[1].expr, Op.pop),
-            TealOp(arg, Op.int, 1),
+            pt.TealOp(actual.ops[0].expr, pt.Op.byte, "0xA21212EF"),
+            pt.TealOp(actual.ops[1].expr, pt.Op.pop),
+            pt.TealOp(arg, pt.Op.int, 1),
         ]
     )
 
@@ -134,20 +133,20 @@ def test_nonce_base16():
 
 
 def test_nonce_base16_prefix():
-    arg = Int(1)
-    expr = Nonce("base16", "0xA21212EF", arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.Nonce("base16", "0xA21212EF", arg)
+    assert expr.type_of() == pt.TealType.uint64
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     # copying expr from actual.ops[0] and actual.ops[1] because they can't be determined from outside code.
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(actual.ops[0].expr, Op.byte, "0xA21212EF"),
-            TealOp(actual.ops[1].expr, Op.pop),
-            TealOp(arg, Op.int, 1),
+            pt.TealOp(actual.ops[0].expr, pt.Op.byte, "0xA21212EF"),
+            pt.TealOp(actual.ops[1].expr, pt.Op.pop),
+            pt.TealOp(arg, pt.Op.int, 1),
         ]
     )
 
@@ -155,20 +154,20 @@ def test_nonce_base16_prefix():
 
 
 def test_nonce_base16_empty():
-    arg = Int(6)
-    expr = Nonce("base16", "", arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(6)
+    expr = pt.Nonce("base16", "", arg)
+    assert expr.type_of() == pt.TealType.uint64
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     # copying expr from actual.ops[0] and actual.ops[1] because they can't be determined from outside code.
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(actual.ops[0].expr, Op.byte, "0x"),
-            TealOp(actual.ops[1].expr, Op.pop),
-            TealOp(arg, Op.int, 6),
+            pt.TealOp(actual.ops[0].expr, pt.Op.byte, "0x"),
+            pt.TealOp(actual.ops[1].expr, pt.Op.pop),
+            pt.TealOp(arg, pt.Op.int, 6),
         ]
     )
 
@@ -176,18 +175,18 @@ def test_nonce_base16_empty():
 
 
 def test_nonce_invalid():
-    with pytest.raises(TealInputError):
-        Nonce("base23", "", Int(1))
+    with pytest.raises(pt.TealInputError):
+        pt.Nonce("base23", "", pt.Int(1))
 
-    with pytest.raises(TealInputError):
-        Nonce("base32", "Zm9vYmE=", Int(1))
+    with pytest.raises(pt.TealInputError):
+        pt.Nonce("base32", "Zm9vYmE=", pt.Int(1))
 
-    with pytest.raises(TealInputError):
-        Nonce("base64", "?????", Int(1))
+    with pytest.raises(pt.TealInputError):
+        pt.Nonce("base64", "?????", pt.Int(1))
 
-    with pytest.raises(TealInputError):
-        Nonce(
+    with pytest.raises(pt.TealInputError):
+        pt.Nonce(
             "base16",
             "7Z5PWO2C6LFNQFGHWKSK5H47IQP5OJW2M3HA2QPXTY3WTNP5NU2MHBW27M",
-            Int(1),
+            pt.Int(1),
         )
diff --git a/pyteal/ast/return_test.py b/pyteal/ast/return_test.py
index 8d8761ffc..85b1013b4 100644
--- a/pyteal/ast/return_test.py
+++ b/pyteal/ast/return_test.py
@@ -1,57 +1,56 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions(version=4)
+options = pt.CompileOptions(version=4)
 
 
 def test_main_return():
-    arg = Int(1)
-    expr = Return(arg)
-    assert expr.type_of() == TealType.none
+    arg = pt.Int(1)
+    expr = pt.Return(arg)
+    assert expr.type_of() == pt.TealType.none
     assert expr.has_return()
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 1), TealOp(expr, Op.return_)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 1), pt.TealOp(expr, pt.Op.return_)]
+    )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_main_return_invalid():
-    with pytest.raises(TealCompileError):
-        Return(Txn.receiver()).__teal__(options)
+    with pytest.raises(pt.TealCompileError):
+        pt.Return(pt.Txn.receiver()).__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        Return().__teal__(options)
+    with pytest.raises(pt.TealCompileError):
+        pt.Return().__teal__(options)
 
 
 def test_subroutine_return_value():
     cases = (
-        (TealType.uint64, Int(1), Op.int, 1),
-        (TealType.bytes, Bytes("value"), Op.byte, '"value"'),
-        (TealType.anytype, Int(1), Op.int, 1),
-        (TealType.anytype, Bytes("value"), Op.byte, '"value"'),
+        (pt.TealType.uint64, pt.Int(1), pt.Op.int, 1),
+        (pt.TealType.bytes, pt.Bytes("value"), pt.Op.byte, '"value"'),
+        (pt.TealType.anytype, pt.Int(1), pt.Op.int, 1),
+        (pt.TealType.anytype, pt.Bytes("value"), pt.Op.byte, '"value"'),
     )
 
     for (tealType, value, op, opValue) in cases:
-        expr = Return(value)
+        expr = pt.Return(value)
 
         def mySubroutine():
             return expr
 
-        subroutine = SubroutineDefinition(mySubroutine, tealType)
+        subroutine = pt.SubroutineDefinition(mySubroutine, tealType)
 
-        assert expr.type_of() == TealType.none
+        assert expr.type_of() == pt.TealType.none
         assert expr.has_return()
 
-        expected = TealSimpleBlock(
-            [TealOp(value, op, opValue), TealOp(expr, Op.retsub)]
+        expected = pt.TealSimpleBlock(
+            [pt.TealOp(value, op, opValue), pt.TealOp(expr, pt.Op.retsub)]
         )
 
         options.setSubroutine(subroutine)
@@ -59,64 +58,64 @@ def mySubroutine():
         options.setSubroutine(None)
 
         actual.addIncoming()
-        actual = TealBlock.NormalizeBlocks(actual)
+        actual = pt.TealBlock.NormalizeBlocks(actual)
 
         assert actual == expected
 
 
 def test_subroutine_return_value_invalid():
     cases = (
-        (TealType.bytes, Int(1)),
-        (TealType.uint64, Bytes("value")),
+        (pt.TealType.bytes, pt.Int(1)),
+        (pt.TealType.uint64, pt.Bytes("value")),
     )
 
     for (tealType, value) in cases:
-        expr = Return(value)
+        expr = pt.Return(value)
 
         def mySubroutine():
             return expr
 
-        subroutine = SubroutineDefinition(mySubroutine, tealType)
+        subroutine = pt.SubroutineDefinition(mySubroutine, tealType)
 
         options.setSubroutine(subroutine)
-        with pytest.raises(TealCompileError):
+        with pytest.raises(pt.TealCompileError):
             expr.__teal__(options)
         options.setSubroutine(None)
 
 
 def test_subroutine_return_none():
-    expr = Return()
+    expr = pt.Return()
 
     def mySubroutine():
         return expr
 
-    subroutine = SubroutineDefinition(mySubroutine, TealType.none)
+    subroutine = pt.SubroutineDefinition(mySubroutine, pt.TealType.none)
 
-    assert expr.type_of() == TealType.none
+    assert expr.type_of() == pt.TealType.none
     assert expr.has_return()
 
-    expected = TealSimpleBlock([TealOp(expr, Op.retsub)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.retsub)])
 
     options.setSubroutine(subroutine)
     actual, _ = expr.__teal__(options)
     options.setSubroutine(None)
 
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_subroutine_return_none_invalid():
-    for value in (Int(1), Bytes("value")):
-        expr = Return(value)
+    for value in (pt.Int(1), pt.Bytes("value")):
+        expr = pt.Return(value)
 
         def mySubroutine():
             return expr
 
-        subroutine = SubroutineDefinition(mySubroutine, TealType.none)
+        subroutine = pt.SubroutineDefinition(mySubroutine, pt.TealType.none)
 
         options.setSubroutine(subroutine)
-        with pytest.raises(TealCompileError):
+        with pytest.raises(pt.TealCompileError):
             expr.__teal__(options)
         options.setSubroutine(None)
diff --git a/pyteal/ast/scratch_test.py b/pyteal/ast/scratch_test.py
index 6379efb1c..6aee2c41c 100644
--- a/pyteal/ast/scratch_test.py
+++ b/pyteal/ast/scratch_test.py
@@ -1,42 +1,40 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_scratch_slot():
-    slot = ScratchSlot()
+    slot = pt.ScratchSlot()
     assert slot == slot
     assert slot.__hash__() == slot.__hash__()
-    assert slot != ScratchSlot()
+    assert slot != pt.ScratchSlot()
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert (
             slot.store().__teal__(options)[0]
-            == ScratchStackStore(slot).__teal__(options)[0]
+            == pt.ScratchStackStore(slot).__teal__(options)[0]
         )
         assert (
-            slot.store(Int(1)).__teal__(options)[0]
-            == ScratchStore(slot, Int(1)).__teal__(options)[0]
+            slot.store(pt.Int(1)).__teal__(options)[0]
+            == pt.ScratchStore(slot, pt.Int(1)).__teal__(options)[0]
         )
 
-        assert slot.load().type_of() == TealType.anytype
-        assert slot.load(TealType.uint64).type_of() == TealType.uint64
+        assert slot.load().type_of() == pt.TealType.anytype
+        assert slot.load(pt.TealType.uint64).type_of() == pt.TealType.uint64
         assert (
-            slot.load().__teal__(options)[0] == ScratchLoad(slot).__teal__(options)[0]
+            slot.load().__teal__(options)[0]
+            == pt.ScratchLoad(slot).__teal__(options)[0]
         )
 
 
 def test_scratch_load_default():
-    slot = ScratchSlot()
-    expr = ScratchLoad(slot)
-    assert expr.type_of() == TealType.anytype
+    slot = pt.ScratchSlot()
+    expr = pt.ScratchLoad(slot)
+    assert expr.type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock([TealOp(expr, Op.load, slot)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.load, slot)])
 
     actual, _ = expr.__teal__(options)
 
@@ -44,25 +42,25 @@ def test_scratch_load_default():
 
 
 def test_scratch_load_index_expression():
-    expr = ScratchLoad(slot=None, index_expression=Int(1337))
-    assert expr.type_of() == TealType.anytype
+    expr = pt.ScratchLoad(slot=None, index_expression=pt.Int(1337))
+    assert expr.type_of() == pt.TealType.anytype
 
-    expected = TealSimpleBlock([TealOp(Int(1337), Op.int, 1337)])
-    expected.setNextBlock(TealSimpleBlock([TealOp(None, Op.loads)]))
+    expected = pt.TealSimpleBlock([pt.TealOp(pt.Int(1337), pt.Op.int, 1337)])
+    expected.setNextBlock(pt.TealSimpleBlock([pt.TealOp(None, pt.Op.loads)]))
 
     actual, _ = expr.__teal__(options)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_scratch_load_type():
-    for type in (TealType.uint64, TealType.bytes, TealType.anytype):
-        slot = ScratchSlot()
-        expr = ScratchLoad(slot, type)
+    for type in (pt.TealType.uint64, pt.TealType.bytes, pt.TealType.anytype):
+        slot = pt.ScratchSlot()
+        expr = pt.ScratchLoad(slot, type)
         assert expr.type_of() == type
 
-        expected = TealSimpleBlock([TealOp(expr, Op.load, slot)])
+        expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.load, slot)])
 
         actual, _ = expr.__teal__(options)
 
@@ -71,17 +69,17 @@ def test_scratch_load_type():
 
 def test_scratch_store():
     for value in (
-        Int(1),
-        Bytes("test"),
-        App.globalGet(Bytes("key")),
-        If(Int(1), Int(2), Int(3)),
+        pt.Int(1),
+        pt.Bytes("test"),
+        pt.App.globalGet(pt.Bytes("key")),
+        pt.If(pt.Int(1), pt.Int(2), pt.Int(3)),
     ):
-        slot = ScratchSlot()
-        expr = ScratchStore(slot, value)
-        assert expr.type_of() == TealType.none
+        slot = pt.ScratchSlot()
+        expr = pt.ScratchStore(slot, value)
+        assert expr.type_of() == pt.TealType.none
 
         expected, valueEnd = value.__teal__(options)
-        storeBlock = TealSimpleBlock([TealOp(expr, Op.store, slot)])
+        storeBlock = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.store, slot)])
         valueEnd.setNextBlock(storeBlock)
 
         actual, _ = expr.__teal__(options)
@@ -91,33 +89,33 @@ def test_scratch_store():
 
 def test_scratch_store_index_expression():
     for value in (
-        Int(1),
-        Bytes("test"),
-        App.globalGet(Bytes("key")),
-        If(Int(1), Int(2), Int(3)),
+        pt.Int(1),
+        pt.Bytes("test"),
+        pt.App.globalGet(pt.Bytes("key")),
+        pt.If(pt.Int(1), pt.Int(2), pt.Int(3)),
     ):
-        expr = ScratchStore(slot=None, value=value, index_expression=Int(1337))
-        assert expr.type_of() == TealType.none
+        expr = pt.ScratchStore(slot=None, value=value, index_expression=pt.Int(1337))
+        assert expr.type_of() == pt.TealType.none
 
-        expected = TealSimpleBlock([TealOp(None, Op.int, 1337)])
+        expected = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1337)])
         valueStart, valueEnd = value.__teal__(options)
         expected.setNextBlock(valueStart)
 
-        storeBlock = TealSimpleBlock([TealOp(expr, Op.stores)])
+        storeBlock = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.stores)])
         valueEnd.setNextBlock(storeBlock)
 
         actual, _ = expr.__teal__(options)
 
-        with TealComponent.Context.ignoreExprEquality():
+        with pt.TealComponent.Context.ignoreExprEquality():
             assert actual == expected
 
 
 def test_scratch_stack_store():
-    slot = ScratchSlot()
-    expr = ScratchStackStore(slot)
-    assert expr.type_of() == TealType.none
+    slot = pt.ScratchSlot()
+    expr = pt.ScratchStackStore(slot)
+    assert expr.type_of() == pt.TealType.none
 
-    expected = TealSimpleBlock([TealOp(expr, Op.store, slot)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.store, slot)])
 
     actual, _ = expr.__teal__(options)
 
@@ -125,11 +123,11 @@ def test_scratch_stack_store():
 
 
 def test_scratch_assign_id():
-    slot = ScratchSlot(255)
-    expr = ScratchStackStore(slot)
-    assert expr.type_of() == TealType.none
+    slot = pt.ScratchSlot(255)
+    expr = pt.ScratchStackStore(slot)
+    assert expr.type_of() == pt.TealType.none
 
-    expected = TealSimpleBlock([TealOp(expr, Op.store, slot)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.store, slot)])
 
     actual, _ = expr.__teal__(options)
 
@@ -137,26 +135,26 @@ def test_scratch_assign_id():
 
 
 def test_scratch_assign_id_invalid():
-    with pytest.raises(TealInputError):
-        slot = ScratchSlot(-1)
+    with pytest.raises(pt.TealInputError):
+        pt.ScratchSlot(-1)
 
-    with pytest.raises(TealInputError):
-        slot = ScratchSlot(NUM_SLOTS)
+    with pytest.raises(pt.TealInputError):
+        pt.ScratchSlot(pt.NUM_SLOTS)
 
 
 def test_scratch_index():
-    slot = ScratchSlot()
+    slot = pt.ScratchSlot()
 
-    index = ScratchIndex(slot)
+    index = pt.ScratchIndex(slot)
     assert index.slot is slot
 
     assert str(index) == "(ScratchIndex " + str(slot) + ")"
 
-    assert index.type_of() == TealType.uint64
+    assert index.type_of() == pt.TealType.uint64
 
     assert not index.has_return()
 
-    expected = TealSimpleBlock([TealOp(index, Op.int, slot)])
+    expected = pt.TealSimpleBlock([pt.TealOp(index, pt.Op.int, slot)])
     actual, _ = index.__teal__(options)
 
     assert actual == expected
diff --git a/pyteal/ast/scratchvar_test.py b/pyteal/ast/scratchvar_test.py
index b757db862..e513f51a1 100644
--- a/pyteal/ast/scratchvar_test.py
+++ b/pyteal/ast/scratchvar_test.py
@@ -1,217 +1,214 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_scratchvar_type():
-    myvar_default = ScratchVar()
-    assert myvar_default.storage_type() == TealType.anytype
-    assert myvar_default.store(Bytes("value")).type_of() == TealType.none
-    assert myvar_default.load().type_of() == TealType.anytype
+    myvar_default = pt.ScratchVar()
+    assert myvar_default.storage_type() == pt.TealType.anytype
+    assert myvar_default.store(pt.Bytes("value")).type_of() == pt.TealType.none
+    assert myvar_default.load().type_of() == pt.TealType.anytype
 
-    with pytest.raises(TealTypeError):
-        myvar_default.store(Pop(Int(1)))
+    with pytest.raises(pt.TealTypeError):
+        myvar_default.store(pt.Pop(pt.Int(1)))
 
-    myvar_int = ScratchVar(TealType.uint64)
-    assert myvar_int.storage_type() == TealType.uint64
-    assert myvar_int.store(Int(1)).type_of() == TealType.none
-    assert myvar_int.load().type_of() == TealType.uint64
+    myvar_int = pt.ScratchVar(pt.TealType.uint64)
+    assert myvar_int.storage_type() == pt.TealType.uint64
+    assert myvar_int.store(pt.Int(1)).type_of() == pt.TealType.none
+    assert myvar_int.load().type_of() == pt.TealType.uint64
 
-    with pytest.raises(TealTypeError):
-        myvar_int.store(Bytes("value"))
+    with pytest.raises(pt.TealTypeError):
+        myvar_int.store(pt.Bytes("value"))
 
-    with pytest.raises(TealTypeError):
-        myvar_int.store(Pop(Int(1)))
+    with pytest.raises(pt.TealTypeError):
+        myvar_int.store(pt.Pop(pt.Int(1)))
 
-    myvar_bytes = ScratchVar(TealType.bytes)
-    assert myvar_bytes.storage_type() == TealType.bytes
-    assert myvar_bytes.store(Bytes("value")).type_of() == TealType.none
-    assert myvar_bytes.load().type_of() == TealType.bytes
+    myvar_bytes = pt.ScratchVar(pt.TealType.bytes)
+    assert myvar_bytes.storage_type() == pt.TealType.bytes
+    assert myvar_bytes.store(pt.Bytes("value")).type_of() == pt.TealType.none
+    assert myvar_bytes.load().type_of() == pt.TealType.bytes
 
-    with pytest.raises(TealTypeError):
-        myvar_bytes.store(Int(0))
+    with pytest.raises(pt.TealTypeError):
+        myvar_bytes.store(pt.Int(0))
 
-    with pytest.raises(TealTypeError):
-        myvar_bytes.store(Pop(Int(1)))
+    with pytest.raises(pt.TealTypeError):
+        myvar_bytes.store(pt.Pop(pt.Int(1)))
 
 
 def test_scratchvar_store():
-    myvar = ScratchVar(TealType.bytes)
-    arg = Bytes("value")
+    myvar = pt.ScratchVar(pt.TealType.bytes)
+    arg = pt.Bytes("value")
     expr = myvar.store(arg)
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.byte, '"value"'),
-            TealOp(expr, Op.store, myvar.slot),
+            pt.TealOp(arg, pt.Op.byte, '"value"'),
+            pt.TealOp(expr, pt.Op.store, myvar.slot),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_scratchvar_load():
-    myvar = ScratchVar()
+    myvar = pt.ScratchVar()
     expr = myvar.load()
 
-    expected = TealSimpleBlock([TealOp(expr, Op.load, myvar.slot)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.load, myvar.slot)])
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_scratchvar_index():
-    myvar = ScratchVar()
+    myvar = pt.ScratchVar()
     expr = myvar.index()
 
-    expected = TealSimpleBlock([TealOp(expr, Op.int, myvar.slot)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.int, myvar.slot)])
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_scratchvar_assign_store():
     slotId = 2
-    myvar = ScratchVar(TealType.uint64, slotId)
-    arg = Int(10)
+    myvar = pt.ScratchVar(pt.TealType.uint64, slotId)
+    arg = pt.Int(10)
     expr = myvar.store(arg)
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg, Op.int, 10),
-            TealOp(expr, Op.store, myvar.slot),
+            pt.TealOp(arg, pt.Op.int, 10),
+            pt.TealOp(expr, pt.Op.store, myvar.slot),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_scratchvar_assign_load():
     slotId = 5
-    myvar = ScratchVar(slotId=slotId)
+    myvar = pt.ScratchVar(slotId=slotId)
     expr = myvar.load()
 
-    expected = TealSimpleBlock([TealOp(expr, Op.load, myvar.slot)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.load, myvar.slot)])
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_dynamic_scratchvar_type():
-    myvar_default = DynamicScratchVar()
-    assert myvar_default.storage_type() == TealType.anytype
-    assert myvar_default.store(Bytes("value")).type_of() == TealType.none
-    assert myvar_default.load().type_of() == TealType.anytype
+    myvar_default = pt.DynamicScratchVar()
+    assert myvar_default.storage_type() == pt.TealType.anytype
+    assert myvar_default.store(pt.Bytes("value")).type_of() == pt.TealType.none
+    assert myvar_default.load().type_of() == pt.TealType.anytype
 
-    with pytest.raises(TealTypeError):
-        myvar_default.store(Pop(Int(1)))
+    with pytest.raises(pt.TealTypeError):
+        myvar_default.store(pt.Pop(pt.Int(1)))
 
-    myvar_int = DynamicScratchVar(TealType.uint64)
-    assert myvar_int.storage_type() == TealType.uint64
-    assert myvar_int.store(Int(1)).type_of() == TealType.none
-    assert myvar_int.load().type_of() == TealType.uint64
+    myvar_int = pt.DynamicScratchVar(pt.TealType.uint64)
+    assert myvar_int.storage_type() == pt.TealType.uint64
+    assert myvar_int.store(pt.Int(1)).type_of() == pt.TealType.none
+    assert myvar_int.load().type_of() == pt.TealType.uint64
 
-    with pytest.raises(TealTypeError):
-        myvar_int.store(Bytes("value"))
+    with pytest.raises(pt.TealTypeError):
+        myvar_int.store(pt.Bytes("value"))
 
-    with pytest.raises(TealTypeError):
-        myvar_int.store(Pop(Int(1)))
+    with pytest.raises(pt.TealTypeError):
+        myvar_int.store(pt.Pop(pt.Int(1)))
 
-    myvar_bytes = DynamicScratchVar(TealType.bytes)
-    assert myvar_bytes.storage_type() == TealType.bytes
-    assert myvar_bytes.store(Bytes("value")).type_of() == TealType.none
-    assert myvar_bytes.load().type_of() == TealType.bytes
+    myvar_bytes = pt.DynamicScratchVar(pt.TealType.bytes)
+    assert myvar_bytes.storage_type() == pt.TealType.bytes
+    assert myvar_bytes.store(pt.Bytes("value")).type_of() == pt.TealType.none
+    assert myvar_bytes.load().type_of() == pt.TealType.bytes
 
-    with pytest.raises(TealTypeError):
-        myvar_bytes.store(Int(0))
+    with pytest.raises(pt.TealTypeError):
+        myvar_bytes.store(pt.Int(0))
 
-    with pytest.raises(TealTypeError):
-        myvar_bytes.store(Pop(Int(1)))
+    with pytest.raises(pt.TealTypeError):
+        myvar_bytes.store(pt.Pop(pt.Int(1)))
 
 
 def test_dynamic_scratchvar_load():
-    myvar = DynamicScratchVar()
+    myvar = pt.DynamicScratchVar()
     expr = myvar.load()
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(ScratchLoad(myvar.slot), Op.load, myvar.slot),
-            TealOp(expr, Op.loads),
+            pt.TealOp(pt.ScratchLoad(myvar.slot), pt.Op.load, myvar.slot),
+            pt.TealOp(expr, pt.Op.loads),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_dynamic_scratchvar_store():
-    myvar = DynamicScratchVar(TealType.bytes)
-    arg = Bytes("value")
+    myvar = pt.DynamicScratchVar(pt.TealType.bytes)
+    arg = pt.Bytes("value")
     expr = myvar.store(arg)
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(ScratchLoad(myvar.slot), Op.load, myvar.slot),
-            TealOp(arg, Op.byte, '"value"'),
-            TealOp(expr, Op.stores),
+            pt.TealOp(pt.ScratchLoad(myvar.slot), pt.Op.load, myvar.slot),
+            pt.TealOp(arg, pt.Op.byte, '"value"'),
+            pt.TealOp(expr, pt.Op.stores),
         ]
     )
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_dynamic_scratchvar_index():
-    myvar = DynamicScratchVar()
+    myvar = pt.DynamicScratchVar()
     expr = myvar.index()
 
-    expected = TealSimpleBlock([TealOp(expr, Op.load, myvar.slot)])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.load, myvar.slot)])
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_dynamic_scratchvar_cannot_set_index_to_another_dynamic():
-    myvar = DynamicScratchVar()
+    myvar = pt.DynamicScratchVar()
     myvar.load()
 
-    regvar = ScratchVar()
+    regvar = pt.ScratchVar()
     myvar.set_index(regvar)
 
-    dynvar = DynamicScratchVar()
+    dynvar = pt.DynamicScratchVar()
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         myvar.set_index(dynvar)
diff --git a/pyteal/ast/seq_test.py b/pyteal/ast/seq_test.py
index 0487a558f..be0a84198 100644
--- a/pyteal/ast/seq_test.py
+++ b/pyteal/ast/seq_test.py
@@ -1,19 +1,16 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_seq_zero():
-    for expr in (Seq(), Seq([])):
-        assert expr.type_of() == TealType.none
+    for expr in (pt.Seq(), pt.Seq([])):
+        assert expr.type_of() == pt.TealType.none
         assert not expr.has_return()
 
-        expected = TealSimpleBlock([])
+        expected = pt.TealSimpleBlock([])
 
         actual, _ = expr.__teal__(options)
 
@@ -21,43 +18,43 @@ def test_seq_zero():
 
 
 def test_seq_one():
-    items = [Int(0)]
-    expr = Seq(items)
-    assert expr.type_of() == TealType.uint64
+    items = [pt.Int(0)]
+    expr = pt.Seq(items)
+    assert expr.type_of() == pt.TealType.uint64
 
     expected, _ = items[0].__teal__(options)
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_seq_two():
-    items = [App.localPut(Int(0), Bytes("key"), Int(1)), Int(7)]
-    expr = Seq(items)
+    items = [pt.App.localPut(pt.Int(0), pt.Bytes("key"), pt.Int(1)), pt.Int(7)]
+    expr = pt.Seq(items)
     assert expr.type_of() == items[-1].type_of()
 
     expected, first_end = items[0].__teal__(options)
     first_end.setNextBlock(items[1].__teal__(options)[0])
     expected.addIncoming()
-    expected = TealBlock.NormalizeBlocks(expected)
+    expected = pt.TealBlock.NormalizeBlocks(expected)
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_seq_three():
     items = [
-        App.localPut(Int(0), Bytes("key1"), Int(1)),
-        App.localPut(Int(1), Bytes("key2"), Bytes("value2")),
-        Pop(Bytes("end")),
+        pt.App.localPut(pt.Int(0), pt.Bytes("key1"), pt.Int(1)),
+        pt.App.localPut(pt.Int(1), pt.Bytes("key2"), pt.Bytes("value2")),
+        pt.Pop(pt.Bytes("end")),
     ]
-    expr = Seq(items)
+    expr = pt.Seq(items)
     assert expr.type_of() == items[-1].type_of()
 
     expected, first_end = items[0].__teal__(options)
@@ -67,42 +64,49 @@ def test_seq_three():
     second_end.setNextBlock(third_start)
 
     expected.addIncoming()
-    expected = TealBlock.NormalizeBlocks(expected)
+    expected = pt.TealBlock.NormalizeBlocks(expected)
 
     actual, _ = expr.__teal__(options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_seq_has_return():
-    exprWithReturn = Seq([App.localPut(Int(0), Bytes("key1"), Int(1)), Return(Int(1))])
+    exprWithReturn = pt.Seq(
+        [
+            pt.App.localPut(pt.Int(0), pt.Bytes("key1"), pt.Int(1)),
+            pt.Return(pt.Int(1)),
+        ]
+    )
     assert exprWithReturn.has_return()
 
-    exprWithoutReturn = Seq([App.localPut(Int(0), Bytes("key1"), Int(1)), Int(1)])
+    exprWithoutReturn = pt.Seq(
+        [pt.App.localPut(pt.Int(0), pt.Bytes("key1"), pt.Int(1)), pt.Int(1)]
+    )
     assert not exprWithoutReturn.has_return()
 
 
 def test_seq_invalid():
-    with pytest.raises(TealTypeError):
-        Seq([Int(1), Pop(Int(2))])
+    with pytest.raises(pt.TealTypeError):
+        pt.Seq([pt.Int(1), pt.Pop(pt.Int(2))])
 
-    with pytest.raises(TealTypeError):
-        Seq([Int(1), Int(2)])
+    with pytest.raises(pt.TealTypeError):
+        pt.Seq([pt.Int(1), pt.Int(2)])
 
-    with pytest.raises(TealTypeError):
-        Seq([Seq([Pop(Int(1)), Int(2)]), Int(3)])
+    with pytest.raises(pt.TealTypeError):
+        pt.Seq([pt.Seq([pt.Pop(pt.Int(1)), pt.Int(2)]), pt.Int(3)])
 
 
 def test_seq_overloads_equivalence():
     items = [
-        App.localPut(Int(0), Bytes("key1"), Int(1)),
-        App.localPut(Int(1), Bytes("key2"), Bytes("value2")),
-        Pop(Bytes("end")),
+        pt.App.localPut(pt.Int(0), pt.Bytes("key1"), pt.Int(1)),
+        pt.App.localPut(pt.Int(1), pt.Bytes("key2"), pt.Bytes("value2")),
+        pt.Pop(pt.Bytes("end")),
     ]
-    expr1 = Seq(items)
-    expr2 = Seq(*items)
+    expr1 = pt.Seq(items)
+    expr2 = pt.Seq(*items)
 
     expected = expr1.__teal__(options)
     actual = expr2.__teal__(options)
diff --git a/pyteal/ast/subroutine_test.py b/pyteal/ast/subroutine_test.py
index e7f93d901..ed66ec1e9 100644
--- a/pyteal/ast/subroutine_test.py
+++ b/pyteal/ast/subroutine_test.py
@@ -1,44 +1,43 @@
 from typing import List
 import pytest
 
-from .. import *
+import pyteal as pt
 from .subroutine import evaluateSubroutine
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions, Return
-
-options = CompileOptions(version=4)
+options = pt.CompileOptions(version=4)
 
 
 def test_subroutine_definition():
     def fn0Args():
-        return Return()
+        return pt.Return()
 
     def fn1Args(a1):
-        return Return()
+        return pt.Return()
 
     def fn2Args(a1, a2):
-        return Return()
+        return pt.Return()
 
     def fn10Args(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10):
-        return Return()
+        return pt.Return()
 
-    lam0Args = lambda: Return()
-    lam1Args = lambda a1: Return()
-    lam2Args = lambda a1, a2: Return()
-    lam10Args = lambda a1, a2, a3, a4, a5, a6, a7, a8, a9, a10: Return()
+    lam0Args = lambda: pt.Return()  # noqa: E731
+    lam1Args = lambda a1: pt.Return()  # noqa: E731
+    lam2Args = lambda a1, a2: pt.Return()  # noqa: E731
+    lam10Args = (
+        lambda a1, a2, a3, a4, a5, a6, a7, a8, a9, a10: pt.Return()
+    )  # noqa: E731
 
-    def fnWithExprAnnotations(a: Expr, b: Expr) -> Expr:
-        return Return()
+    def fnWithExprAnnotations(a: pt.Expr, b: pt.Expr) -> pt.Expr:
+        return pt.Return()
 
-    def fnWithOnlyReturnExprAnnotations(a, b) -> Expr:
-        return Return()
+    def fnWithOnlyReturnExprAnnotations(a, b) -> pt.Expr:
+        return pt.Return()
 
-    def fnWithOnlyArgExprAnnotations(a: Expr, b: Expr):
-        return Return()
+    def fnWithOnlyArgExprAnnotations(a: pt.Expr, b: pt.Expr):
+        return pt.Return()
 
-    def fnWithPartialExprAnnotations(a, b: Expr) -> Expr:
-        return Return()
+    def fnWithPartialExprAnnotations(a, b: pt.Expr) -> pt.Expr:
+        return pt.Return()
 
     cases = (
         (fn0Args, 0, "fn0Args"),
@@ -56,84 +55,84 @@ def fnWithPartialExprAnnotations(a, b: Expr) -> Expr:
     )
 
     for (fn, numArgs, name) in cases:
-        definition = SubroutineDefinition(fn, TealType.none)
+        definition = pt.SubroutineDefinition(fn, pt.TealType.none)
         assert definition.argumentCount() == numArgs
         assert definition.name() == name
 
         if numArgs > 0:
-            with pytest.raises(TealInputError):
-                definition.invoke([Int(1)] * (numArgs - 1))
+            with pytest.raises(pt.TealInputError):
+                definition.invoke([pt.Int(1)] * (numArgs - 1))
 
-        with pytest.raises(TealInputError):
-            definition.invoke([Int(1)] * (numArgs + 1))
+        with pytest.raises(pt.TealInputError):
+            definition.invoke([pt.Int(1)] * (numArgs + 1))
 
         if numArgs > 0:
-            with pytest.raises(TealInputError):
+            with pytest.raises(pt.TealInputError):
                 definition.invoke([1] * numArgs)
 
-        args = [Int(1)] * numArgs
+        args = [pt.Int(1)] * numArgs
         invocation = definition.invoke(args)
-        assert isinstance(invocation, SubroutineCall)
+        assert isinstance(invocation, pt.SubroutineCall)
         assert invocation.subroutine is definition
         assert invocation.args == args
 
 
 def test_subroutine_invocation_param_types():
     def fnWithNoAnnotations(a, b):
-        return Return()
+        return pt.Return()
 
-    def fnWithExprAnnotations(a: Expr, b: Expr) -> Expr:
-        return Return()
+    def fnWithExprAnnotations(a: pt.Expr, b: pt.Expr) -> pt.Expr:
+        return pt.Return()
 
-    def fnWithSVAnnotations(a: ScratchVar, b: ScratchVar):
-        return Return()
+    def fnWithSVAnnotations(a: pt.ScratchVar, b: pt.ScratchVar):
+        return pt.Return()
 
-    def fnWithMixedAnns1(a: ScratchVar, b: Expr) -> Expr:
-        return Return()
+    def fnWithMixedAnns1(a: pt.ScratchVar, b: pt.Expr) -> pt.Expr:
+        return pt.Return()
 
-    def fnWithMixedAnns2(a: ScratchVar, b) -> Expr:
-        return Return()
+    def fnWithMixedAnns2(a: pt.ScratchVar, b) -> pt.Expr:
+        return pt.Return()
 
-    def fnWithMixedAnns3(a: Expr, b: ScratchVar):
-        return Return()
+    def fnWithMixedAnns3(a: pt.Expr, b: pt.ScratchVar):
+        return pt.Return()
 
-    sv = ScratchVar()
-    x = Int(42)
-    s = Bytes("hello")
+    sv = pt.ScratchVar()
+    x = pt.Int(42)
+    s = pt.Bytes("hello")
     cases = [
         ("vanilla 1", fnWithNoAnnotations, [x, s], None),
         ("vanilla 2", fnWithNoAnnotations, [x, x], None),
-        ("vanilla no sv's allowed 1", fnWithNoAnnotations, [x, sv], TealInputError),
+        ("vanilla no sv's allowed 1", fnWithNoAnnotations, [x, sv], pt.TealInputError),
         ("exprs 1", fnWithExprAnnotations, [x, s], None),
         ("exprs 2", fnWithExprAnnotations, [x, x], None),
-        ("exprs no sv's allowed 1", fnWithExprAnnotations, [x, sv], TealInputError),
+        ("exprs no sv's allowed 1", fnWithExprAnnotations, [x, sv], pt.TealInputError),
         ("all sv's 1", fnWithSVAnnotations, [sv, sv], None),
-        ("all sv's but strings", fnWithSVAnnotations, [s, s], TealInputError),
-        ("all sv's but ints", fnWithSVAnnotations, [x, x], TealInputError),
+        ("all sv's but strings", fnWithSVAnnotations, [s, s], pt.TealInputError),
+        ("all sv's but ints", fnWithSVAnnotations, [x, x], pt.TealInputError),
         ("mixed1 copacetic", fnWithMixedAnns1, [sv, x], None),
-        ("mixed1 flipped", fnWithMixedAnns1, [x, sv], TealInputError),
-        ("mixed1 missing the sv", fnWithMixedAnns1, [x, s], TealInputError),
-        ("mixed1 missing the non-sv", fnWithMixedAnns1, [sv, sv], TealInputError),
+        ("mixed1 flipped", fnWithMixedAnns1, [x, sv], pt.TealInputError),
+        ("mixed1 missing the sv", fnWithMixedAnns1, [x, s], pt.TealInputError),
+        ("mixed1 missing the non-sv", fnWithMixedAnns1, [sv, sv], pt.TealInputError),
         ("mixed2 copacetic", fnWithMixedAnns2, [sv, x], None),
-        ("mixed2 flipped", fnWithMixedAnns2, [x, sv], TealInputError),
-        ("mixed2 missing the sv", fnWithMixedAnns2, [x, s], TealInputError),
-        ("mixed2 missing the non-sv", fnWithMixedAnns2, [sv, sv], TealInputError),
+        ("mixed2 flipped", fnWithMixedAnns2, [x, sv], pt.TealInputError),
+        ("mixed2 missing the sv", fnWithMixedAnns2, [x, s], pt.TealInputError),
+        ("mixed2 missing the non-sv", fnWithMixedAnns2, [sv, sv], pt.TealInputError),
         ("mixed3 copacetic", fnWithMixedAnns3, [s, sv], None),
-        ("mixed3 flipped", fnWithMixedAnns3, [sv, x], TealInputError),
-        ("mixed3 missing the sv", fnWithMixedAnns3, [x, s], TealInputError),
+        ("mixed3 flipped", fnWithMixedAnns3, [sv, x], pt.TealInputError),
+        ("mixed3 missing the sv", fnWithMixedAnns3, [x, s], pt.TealInputError),
     ]
     for case_name, fn, args, err in cases:
-        definition = SubroutineDefinition(fn, TealType.none)
+        definition = pt.SubroutineDefinition(fn, pt.TealType.none)
         assert definition.argumentCount() == len(args), case_name
         assert definition.name() == fn.__name__, case_name
 
         if err is None:
             assert len(definition.by_ref_args) == len(
-                [x for x in args if isinstance(x, ScratchVar)]
+                [x for x in args if isinstance(x, pt.ScratchVar)]
             ), case_name
 
             invocation = definition.invoke(args)
-            assert isinstance(invocation, SubroutineCall), case_name
+            assert isinstance(invocation, pt.SubroutineCall), case_name
             assert invocation.subroutine is definition, case_name
             assert invocation.args == args, case_name
             assert invocation.has_return() is False, case_name
@@ -150,28 +149,28 @@ def fnWithMixedAnns3(a: Expr, b: ScratchVar):
 
 def test_subroutine_definition_invalid():
     def fnWithDefaults(a, b=None):
-        return Return()
+        return pt.Return()
 
     def fnWithKeywordArgs(a, *, b):
-        return Return()
+        return pt.Return()
 
     def fnWithVariableArgs(a, *b):
-        return Return()
+        return pt.Return()
 
-    def fnWithNonExprReturnAnnotation(a, b) -> TealType.uint64:
-        return Return()
+    def fnWithNonExprReturnAnnotation(a, b) -> pt.TealType.uint64:
+        return pt.Return()
 
-    def fnWithNonExprParamAnnotation(a, b: TealType.uint64):
-        return Return()
+    def fnWithNonExprParamAnnotation(a, b: pt.TealType.uint64):
+        return pt.Return()
 
-    def fnWithScratchVarSubclass(a, b: DynamicScratchVar):
-        return Return()
+    def fnWithScratchVarSubclass(a, b: pt.DynamicScratchVar):
+        return pt.Return()
 
-    def fnReturningExprSubclass(a: ScratchVar, b: Expr) -> Return:
-        return Return()
+    def fnReturningExprSubclass(a: pt.ScratchVar, b: pt.Expr) -> pt.Return:
+        return pt.Return()
 
-    def fnWithMixedAnns4AndBytesReturn(a: Expr, b: ScratchVar) -> Bytes:
-        return Bytes("helo")
+    def fnWithMixedAnns4AndBytesReturn(a: pt.Expr, b: pt.ScratchVar) -> pt.Bytes:
+        return pt.Bytes("helo")
 
     cases = (
         (1, "TealInputError('Input to SubroutineDefinition is not callable'"),
@@ -211,20 +210,20 @@ def fnWithMixedAnns4AndBytesReturn(a: Expr, b: ScratchVar) -> Bytes:
     )
 
     for fn, msg in cases:
-        with pytest.raises(TealInputError) as e:
+        with pytest.raises(pt.TealInputError) as e:
             print(f"case=[{msg}]")
-            SubroutineDefinition(fn, TealType.none)
+            pt.SubroutineDefinition(fn, pt.TealType.none)
 
         assert msg in str(e), "failed for case [{}]".format(fn.__name__)
 
 
 def test_subroutine_declaration():
     cases = (
-        (TealType.none, Return()),
-        (TealType.uint64, Return(Int(1))),
-        (TealType.uint64, Int(1)),
-        (TealType.bytes, Bytes("value")),
-        (TealType.anytype, App.globalGet(Bytes("key"))),
+        (pt.TealType.none, pt.Return()),
+        (pt.TealType.uint64, pt.Return(pt.Int(1))),
+        (pt.TealType.uint64, pt.Int(1)),
+        (pt.TealType.bytes, pt.Bytes("value")),
+        (pt.TealType.anytype, pt.App.globalGet(pt.Bytes("key"))),
     )
 
     for (returnType, value) in cases:
@@ -232,9 +231,9 @@ def test_subroutine_declaration():
         def mySubroutine():
             return value
 
-        definition = SubroutineDefinition(mySubroutine, returnType)
+        definition = pt.SubroutineDefinition(mySubroutine, returnType)
 
-        declaration = SubroutineDeclaration(definition, value)
+        declaration = pt.SubroutineDeclaration(definition, value)
         assert declaration.type_of() == value.type_of()
         assert declaration.has_return() == value.has_return()
 
@@ -245,27 +244,32 @@ def mySubroutine():
 
 def test_subroutine_call():
     def mySubroutine():
-        return Return()
+        return pt.Return()
 
-    returnTypes = (TealType.uint64, TealType.bytes, TealType.anytype, TealType.none)
+    returnTypes = (
+        pt.TealType.uint64,
+        pt.TealType.bytes,
+        pt.TealType.anytype,
+        pt.TealType.none,
+    )
 
     argCases = (
         [],
-        [Int(1)],
-        [Int(1), Bytes("value")],
+        [pt.Int(1)],
+        [pt.Int(1), pt.Bytes("value")],
     )
 
     for returnType in returnTypes:
-        definition = SubroutineDefinition(mySubroutine, returnType)
+        definition = pt.SubroutineDefinition(mySubroutine, returnType)
 
         for args in argCases:
-            expr = SubroutineCall(definition, args)
+            expr = pt.SubroutineCall(definition, args)
 
             assert expr.type_of() == returnType
             assert not expr.has_return()
 
-            expected, _ = TealBlock.FromOp(
-                options, TealOp(expr, Op.callsub, definition), *args
+            expected, _ = pt.TealBlock.FromOp(
+                options, pt.TealOp(expr, pt.Op.callsub, definition), *args
             )
 
             actual, _ = expr.__teal__(options)
@@ -274,41 +278,41 @@ def mySubroutine():
 
 
 def test_decorator():
-    assert callable(Subroutine)
-    assert callable(Subroutine(TealType.anytype))
+    assert callable(pt.Subroutine)
+    assert callable(pt.Subroutine(pt.TealType.anytype))
 
-    @Subroutine(TealType.none)
+    @pt.Subroutine(pt.TealType.none)
     def mySubroutine(a):
-        return Return()
+        return pt.Return()
 
-    assert isinstance(mySubroutine, SubroutineFnWrapper)
+    assert isinstance(mySubroutine, pt.SubroutineFnWrapper)
 
-    invocation = mySubroutine(Int(1))
-    assert isinstance(invocation, SubroutineCall)
+    invocation = mySubroutine(pt.Int(1))
+    assert isinstance(invocation, pt.SubroutineCall)
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         mySubroutine()
 
-    with pytest.raises(TealInputError):
-        mySubroutine(Int(1), Int(2))
+    with pytest.raises(pt.TealInputError):
+        mySubroutine(pt.Int(1), pt.Int(2))
 
-    with pytest.raises(TealInputError):
-        mySubroutine(Pop(Int(1)))
+    with pytest.raises(pt.TealInputError):
+        mySubroutine(pt.Pop(pt.Int(1)))
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         mySubroutine(1)
 
-    with pytest.raises(TealInputError):
-        mySubroutine(a=Int(1))
+    with pytest.raises(pt.TealInputError):
+        mySubroutine(a=pt.Int(1))
 
 
 def test_evaluate_subroutine_no_args():
     cases = (
-        (TealType.none, Return()),
-        (TealType.uint64, Int(1) + Int(2)),
-        (TealType.uint64, Return(Int(1) + Int(2))),
-        (TealType.bytes, Bytes("value")),
-        (TealType.bytes, Return(Bytes("value"))),
+        (pt.TealType.none, pt.Return()),
+        (pt.TealType.uint64, pt.Int(1) + pt.Int(2)),
+        (pt.TealType.uint64, pt.Return(pt.Int(1) + pt.Int(2))),
+        (pt.TealType.bytes, pt.Bytes("value")),
+        (pt.TealType.bytes, pt.Return(pt.Bytes("value"))),
     )
 
     for (returnType, returnValue) in cases:
@@ -316,17 +320,17 @@ def test_evaluate_subroutine_no_args():
         def mySubroutine():
             return returnValue
 
-        definition = SubroutineDefinition(mySubroutine, returnType)
+        definition = pt.SubroutineDefinition(mySubroutine, returnType)
 
         declaration = evaluateSubroutine(definition)
-        assert isinstance(declaration, SubroutineDeclaration)
+        assert isinstance(declaration, pt.SubroutineDeclaration)
         assert declaration.subroutine is definition
 
         assert declaration.type_of() == returnValue.type_of()
         assert declaration.has_return() == returnValue.has_return()
 
         options.setSubroutine(definition)
-        expected, _ = Seq([returnValue]).__teal__(options)
+        expected, _ = pt.Seq([returnValue]).__teal__(options)
 
         actual, _ = declaration.__teal__(options)
         options.setSubroutine(None)
@@ -335,39 +339,39 @@ def mySubroutine():
 
 def test_evaluate_subroutine_1_arg():
     cases = (
-        (TealType.none, Return()),
-        (TealType.uint64, Int(1) + Int(2)),
-        (TealType.uint64, Return(Int(1) + Int(2))),
-        (TealType.bytes, Bytes("value")),
-        (TealType.bytes, Return(Bytes("value"))),
+        (pt.TealType.none, pt.Return()),
+        (pt.TealType.uint64, pt.Int(1) + pt.Int(2)),
+        (pt.TealType.uint64, pt.Return(pt.Int(1) + pt.Int(2))),
+        (pt.TealType.bytes, pt.Bytes("value")),
+        (pt.TealType.bytes, pt.Return(pt.Bytes("value"))),
     )
 
     for (returnType, returnValue) in cases:
-        argSlots: List[ScratchSlot] = []
+        argSlots: List[pt.ScratchSlot] = []
 
         def mySubroutine(a1):
-            assert isinstance(a1, ScratchLoad)
+            assert isinstance(a1, pt.ScratchLoad)
             argSlots.append(a1.slot)
             return returnValue
 
-        definition = SubroutineDefinition(mySubroutine, returnType)
+        definition = pt.SubroutineDefinition(mySubroutine, returnType)
 
         declaration = evaluateSubroutine(definition)
-        assert isinstance(declaration, SubroutineDeclaration)
+        assert isinstance(declaration, pt.SubroutineDeclaration)
         assert declaration.subroutine is definition
 
         assert declaration.type_of() == returnValue.type_of()
         assert declaration.has_return() == returnValue.has_return()
 
-        assert isinstance(declaration.body, Seq)
+        assert isinstance(declaration.body, pt.Seq)
         assert len(declaration.body.args) == 2
 
-        assert isinstance(declaration.body.args[0], ScratchStackStore)
+        assert isinstance(declaration.body.args[0], pt.ScratchStackStore)
 
         assert declaration.body.args[0].slot is argSlots[-1]
 
         options.setSubroutine(definition)
-        expected, _ = Seq([declaration.body.args[0], returnValue]).__teal__(options)
+        expected, _ = pt.Seq([declaration.body.args[0], returnValue]).__teal__(options)
 
         actual, _ = declaration.__teal__(options)
         options.setSubroutine(None)
@@ -376,43 +380,43 @@ def mySubroutine(a1):
 
 def test_evaluate_subroutine_2_args():
     cases = (
-        (TealType.none, Return()),
-        (TealType.uint64, Int(1) + Int(2)),
-        (TealType.uint64, Return(Int(1) + Int(2))),
-        (TealType.bytes, Bytes("value")),
-        (TealType.bytes, Return(Bytes("value"))),
+        (pt.TealType.none, pt.Return()),
+        (pt.TealType.uint64, pt.Int(1) + pt.Int(2)),
+        (pt.TealType.uint64, pt.Return(pt.Int(1) + pt.Int(2))),
+        (pt.TealType.bytes, pt.Bytes("value")),
+        (pt.TealType.bytes, pt.Return(pt.Bytes("value"))),
     )
 
     for (returnType, returnValue) in cases:
-        argSlots: List[ScratchSlot] = []
+        argSlots: List[pt.ScratchSlot] = []
 
         def mySubroutine(a1, a2):
-            assert isinstance(a1, ScratchLoad)
+            assert isinstance(a1, pt.ScratchLoad)
             argSlots.append(a1.slot)
-            assert isinstance(a2, ScratchLoad)
+            assert isinstance(a2, pt.ScratchLoad)
             argSlots.append(a2.slot)
             return returnValue
 
-        definition = SubroutineDefinition(mySubroutine, returnType)
+        definition = pt.SubroutineDefinition(mySubroutine, returnType)
 
         declaration = evaluateSubroutine(definition)
-        assert isinstance(declaration, SubroutineDeclaration)
+        assert isinstance(declaration, pt.SubroutineDeclaration)
         assert declaration.subroutine is definition
 
         assert declaration.type_of() == returnValue.type_of()
         assert declaration.has_return() == returnValue.has_return()
 
-        assert isinstance(declaration.body, Seq)
+        assert isinstance(declaration.body, pt.Seq)
         assert len(declaration.body.args) == 3
 
-        assert isinstance(declaration.body.args[0], ScratchStackStore)
-        assert isinstance(declaration.body.args[1], ScratchStackStore)
+        assert isinstance(declaration.body.args[0], pt.ScratchStackStore)
+        assert isinstance(declaration.body.args[1], pt.ScratchStackStore)
 
         assert declaration.body.args[0].slot is argSlots[-1]
         assert declaration.body.args[1].slot is argSlots[-2]
 
         options.setSubroutine(definition)
-        expected, _ = Seq(
+        expected, _ = pt.Seq(
             [declaration.body.args[0], declaration.body.args[1], returnValue]
         ).__teal__(options)
 
@@ -423,42 +427,44 @@ def mySubroutine(a1, a2):
 
 def test_evaluate_subroutine_10_args():
     cases = (
-        (TealType.none, Return()),
-        (TealType.uint64, Int(1) + Int(2)),
-        (TealType.uint64, Return(Int(1) + Int(2))),
-        (TealType.bytes, Bytes("value")),
-        (TealType.bytes, Return(Bytes("value"))),
+        (pt.TealType.none, pt.Return()),
+        (pt.TealType.uint64, pt.Int(1) + pt.Int(2)),
+        (pt.TealType.uint64, pt.Return(pt.Int(1) + pt.Int(2))),
+        (pt.TealType.bytes, pt.Bytes("value")),
+        (pt.TealType.bytes, pt.Return(pt.Bytes("value"))),
     )
 
     for (returnType, returnValue) in cases:
-        argSlots: List[ScratchSlot] = []
+        argSlots: List[pt.ScratchSlot] = []
 
         def mySubroutine(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10):
             for a in (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10):
-                assert isinstance(a, ScratchLoad)
+                assert isinstance(a, pt.ScratchLoad)
                 argSlots.append(a.slot)
             return returnValue
 
-        definition = SubroutineDefinition(mySubroutine, returnType)
+        definition = pt.SubroutineDefinition(mySubroutine, returnType)
 
         declaration = evaluateSubroutine(definition)
-        assert isinstance(declaration, SubroutineDeclaration)
+        assert isinstance(declaration, pt.SubroutineDeclaration)
         assert declaration.subroutine is definition
 
         assert declaration.type_of() == returnValue.type_of()
         assert declaration.has_return() == returnValue.has_return()
 
-        assert isinstance(declaration.body, Seq)
+        assert isinstance(declaration.body, pt.Seq)
         assert len(declaration.body.args) == 11
 
         for i in range(10):
-            assert isinstance(declaration.body.args[i], ScratchStackStore)
+            assert isinstance(declaration.body.args[i], pt.ScratchStackStore)
 
         for i in range(10):
             assert declaration.body.args[i].slot is argSlots[-i - 1]
 
         options.setSubroutine(definition)
-        expected, _ = Seq(declaration.body.args[:10] + [returnValue]).__teal__(options)
+        expected, _ = pt.Seq(declaration.body.args[:10] + [returnValue]).__teal__(
+            options
+        )
 
         actual, _ = declaration.__teal__(options)
         options.setSubroutine(None)
diff --git a/pyteal/ast/substring_test.py b/pyteal/ast/substring_test.py
index c532f299f..2aafeabfd 100644
--- a/pyteal/ast/substring_test.py
+++ b/pyteal/ast/substring_test.py
@@ -1,283 +1,280 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-teal2Options = CompileOptions(version=2)
-teal3Options = CompileOptions(version=3)
-teal4Options = CompileOptions(version=4)
-teal5Options = CompileOptions(version=5)
+teal2Options = pt.CompileOptions(version=2)
+teal3Options = pt.CompileOptions(version=3)
+teal4Options = pt.CompileOptions(version=4)
+teal5Options = pt.CompileOptions(version=5)
 
 
 def test_substring_immediate_v2():
-    args = [Bytes("my string"), Int(0), Int(2)]
-    expr = Substring(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("my string"), pt.Int(0), pt.Int(2)]
+    expr = pt.Substring(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"my string"'),
-            TealOp(expr, Op.substring, 0, 2),
+            pt.TealOp(args[0], pt.Op.byte, '"my string"'),
+            pt.TealOp(expr, pt.Op.substring, 0, 2),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_substring_immediate_v5():
-    args = [Bytes("my string"), Int(1), Int(2)]
-    expr = Substring(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("my string"), pt.Int(1), pt.Int(2)]
+    expr = pt.Substring(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"my string"'),
-            TealOp(expr, Op.extract, 1, 1),
+            pt.TealOp(args[0], pt.Op.byte, '"my string"'),
+            pt.TealOp(expr, pt.Op.extract, 1, 1),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_substring_to_extract():
     my_string = "a" * 257
-    args = [Bytes(my_string), Int(255), Int(257)]
-    expr = Substring(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes(my_string), pt.Int(255), pt.Int(257)]
+    expr = pt.Substring(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"{my_string}"'.format(my_string=my_string)),
-            TealOp(expr, Op.extract, 255, 2),
+            pt.TealOp(args[0], pt.Op.byte, '"{my_string}"'.format(my_string=my_string)),
+            pt.TealOp(expr, pt.Op.extract, 255, 2),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_substring_stack_v2():
     my_string = "a" * 257
-    args = [Bytes(my_string), Int(256), Int(257)]
-    expr = Substring(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes(my_string), pt.Int(256), pt.Int(257)]
+    expr = pt.Substring(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"{my_string}"'.format(my_string=my_string)),
-            TealOp(args[1], Op.int, 256),
-            TealOp(args[2], Op.int, 257),
-            TealOp(expr, Op.substring3),
+            pt.TealOp(args[0], pt.Op.byte, '"{my_string}"'.format(my_string=my_string)),
+            pt.TealOp(args[1], pt.Op.int, 256),
+            pt.TealOp(args[2], pt.Op.int, 257),
+            pt.TealOp(expr, pt.Op.substring3),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_substring_stack_v5():
     my_string = "a" * 257
-    args = [Bytes(my_string), Int(256), Int(257)]
-    expr = Substring(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes(my_string), pt.Int(256), pt.Int(257)]
+    expr = pt.Substring(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"{my_string}"'.format(my_string=my_string)),
-            TealOp(args[1], Op.int, 256),
-            TealOp(Int(1), Op.int, 1),
-            TealOp(expr, Op.extract3),
+            pt.TealOp(args[0], pt.Op.byte, '"{my_string}"'.format(my_string=my_string)),
+            pt.TealOp(args[1], pt.Op.int, 256),
+            pt.TealOp(pt.Int(1), pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.extract3),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_zero_length_substring_immediate():
     my_string = "a" * 257
-    args = [Bytes(my_string), Int(1), Int(1)]
-    expr = Substring(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes(my_string), pt.Int(1), pt.Int(1)]
+    expr = pt.Substring(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"{my_string}"'.format(my_string=my_string)),
-            TealOp(expr, Op.substring, 1, 1),
+            pt.TealOp(args[0], pt.Op.byte, '"{my_string}"'.format(my_string=my_string)),
+            pt.TealOp(expr, pt.Op.substring, 1, 1),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert actual == expected
 
 
 def test_substring_invalid():
-    with pytest.raises(TealTypeError):
-        Substring(Int(0), Int(0), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Substring(pt.Int(0), pt.Int(0), pt.Int(2))
 
-    with pytest.raises(TealTypeError):
-        Substring(Bytes("my string"), Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Substring(pt.Bytes("my string"), pt.Txn.sender(), pt.Int(2))
 
-    with pytest.raises(TealTypeError):
-        Substring(Bytes("my string"), Int(0), Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.Substring(pt.Bytes("my string"), pt.Int(0), pt.Txn.sender())
 
     with pytest.raises(Exception):
-        Substring(Bytes("my string"), Int(1), Int(0)).__teal__(teal5Options)
+        pt.Substring(pt.Bytes("my string"), pt.Int(1), pt.Int(0)).__teal__(teal5Options)
 
 
 def test_extract_immediate():
-    args = [Bytes("my string"), Int(0), Int(2)]
-    expr = Extract(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("my string"), pt.Int(0), pt.Int(2)]
+    expr = pt.Extract(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"my string"'),
-            TealOp(expr, Op.extract, 0, 2),
+            pt.TealOp(args[0], pt.Op.byte, '"my string"'),
+            pt.TealOp(expr, pt.Op.extract, 0, 2),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal4Options)
 
 
 def test_extract_zero():
-    args = [Bytes("my string"), Int(1), Int(0)]
-    expr = Extract(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("my string"), pt.Int(1), pt.Int(0)]
+    expr = pt.Extract(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"my string"'),
-            TealOp(args[1], Op.int, 1),
-            TealOp(args[2], Op.int, 0),
-            TealOp(expr, Op.extract3),
+            pt.TealOp(args[0], pt.Op.byte, '"my string"'),
+            pt.TealOp(args[1], pt.Op.int, 1),
+            pt.TealOp(args[2], pt.Op.int, 0),
+            pt.TealOp(expr, pt.Op.extract3),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal4Options)
 
 
 def test_extract_stack():
     my_string = "*" * 257
-    args = [Bytes(my_string), Int(256), Int(257)]
-    expr = Extract(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes(my_string), pt.Int(256), pt.Int(257)]
+    expr = pt.Extract(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"{my_string}"'.format(my_string=my_string)),
-            TealOp(args[1], Op.int, 256),
-            TealOp(args[2], Op.int, 257),
-            TealOp(expr, Op.extract3),
+            pt.TealOp(args[0], pt.Op.byte, '"{my_string}"'.format(my_string=my_string)),
+            pt.TealOp(args[1], pt.Op.int, 256),
+            pt.TealOp(args[2], pt.Op.int, 257),
+            pt.TealOp(expr, pt.Op.extract3),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal4Options)
 
 
 def test_extract_invalid():
-    with pytest.raises(TealTypeError):
-        Extract(Int(0), Int(0), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Extract(pt.Int(0), pt.Int(0), pt.Int(2))
 
-    with pytest.raises(TealTypeError):
-        Extract(Bytes("my string"), Txn.sender(), Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.Extract(pt.Bytes("my string"), pt.Txn.sender(), pt.Int(2))
 
-    with pytest.raises(TealTypeError):
-        Extract(Bytes("my string"), Int(0), Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.Extract(pt.Bytes("my string"), pt.Int(0), pt.Txn.sender())
 
 
 def test_suffix_immediate():
-    args = [Bytes("my string"), Int(1)]
-    expr = Suffix(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("my string"), pt.Int(1)]
+    expr = pt.Suffix(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"my string"'),
-            TealOp(expr, Op.extract, 1, 0),
+            pt.TealOp(args[0], pt.Op.byte, '"my string"'),
+            pt.TealOp(expr, pt.Op.extract, 1, 0),
         ]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_suffix_stack():
     my_string = "*" * 1024
-    args = [Bytes(my_string), Int(257)]
-    expr = Suffix(args[0], args[1])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes(my_string), pt.Int(257)]
+    expr = pt.Suffix(args[0], args[1])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"{my_string}"'.format(my_string=my_string)),
-            TealOp(args[1], Op.int, 257),
-            TealOp(expr, Op.dig, 1),
-            TealOp(expr, Op.len),
-            TealOp(expr, Op.substring3),
+            pt.TealOp(args[0], pt.Op.byte, '"{my_string}"'.format(my_string=my_string)),
+            pt.TealOp(args[1], pt.Op.int, 257),
+            pt.TealOp(expr, pt.Op.dig, 1),
+            pt.TealOp(expr, pt.Op.len),
+            pt.TealOp(expr, pt.Op.substring3),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_suffix_invalid():
-    with pytest.raises(TealTypeError):
-        Suffix(Int(0), Int(0))
+    with pytest.raises(pt.TealTypeError):
+        pt.Suffix(pt.Int(0), pt.Int(0))
 
-    with pytest.raises(TealTypeError):
-        Suffix(Bytes("my string"), Txn.sender())
+    with pytest.raises(pt.TealTypeError):
+        pt.Suffix(pt.Bytes("my string"), pt.Txn.sender())
diff --git a/pyteal/ast/ternaryexpr_test.py b/pyteal/ast/ternaryexpr_test.py
index 48b35585e..996c58635 100644
--- a/pyteal/ast/ternaryexpr_test.py
+++ b/pyteal/ast/ternaryexpr_test.py
@@ -1,173 +1,170 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-teal2Options = CompileOptions(version=2)
-teal3Options = CompileOptions(version=3)
-teal4Options = CompileOptions(version=4)
-teal5Options = CompileOptions(version=5)
-teal6Options = CompileOptions(version=6)
+teal2Options = pt.CompileOptions(version=2)
+teal3Options = pt.CompileOptions(version=3)
+teal4Options = pt.CompileOptions(version=4)
+teal5Options = pt.CompileOptions(version=5)
+teal6Options = pt.CompileOptions(version=6)
 
 
 def test_ed25519verify():
-    args = [Bytes("data"), Bytes("sig"), Bytes("key")]
-    expr = Ed25519Verify(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Bytes("data"), pt.Bytes("sig"), pt.Bytes("key")]
+    expr = pt.Ed25519Verify(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, '"data"'),
-            TealOp(args[1], Op.byte, '"sig"'),
-            TealOp(args[2], Op.byte, '"key"'),
-            TealOp(expr, Op.ed25519verify),
+            pt.TealOp(args[0], pt.Op.byte, '"data"'),
+            pt.TealOp(args[1], pt.Op.byte, '"sig"'),
+            pt.TealOp(args[2], pt.Op.byte, '"key"'),
+            pt.TealOp(expr, pt.Op.ed25519verify),
         ]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_ed25519verify_invalid():
-    with pytest.raises(TealTypeError):
-        Ed25519Verify(Int(0), Bytes("sig"), Bytes("key"))
+    with pytest.raises(pt.TealTypeError):
+        pt.Ed25519Verify(pt.Int(0), pt.Bytes("sig"), pt.Bytes("key"))
 
-    with pytest.raises(TealTypeError):
-        Ed25519Verify(Bytes("data"), Int(0), Bytes("key"))
+    with pytest.raises(pt.TealTypeError):
+        pt.Ed25519Verify(pt.Bytes("data"), pt.Int(0), pt.Bytes("key"))
 
-    with pytest.raises(TealTypeError):
-        Ed25519Verify(Bytes("data"), Bytes("sig"), Int(0))
+    with pytest.raises(pt.TealTypeError):
+        pt.Ed25519Verify(pt.Bytes("data"), pt.Bytes("sig"), pt.Int(0))
 
 
 def test_set_bit_int():
-    args = [Int(0), Int(2), Int(1)]
-    expr = SetBit(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(0), pt.Int(2), pt.Int(1)]
+    expr = pt.SetBit(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, 0),
-            TealOp(args[1], Op.int, 2),
-            TealOp(args[2], Op.int, 1),
-            TealOp(expr, Op.setbit),
+            pt.TealOp(args[0], pt.Op.int, 0),
+            pt.TealOp(args[1], pt.Op.int, 2),
+            pt.TealOp(args[2], pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.setbit),
         ]
     )
 
     actual, _ = expr.__teal__(teal3Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal2Options)
 
 
 def test_set_bit_bytes():
-    args = [Bytes("base16", "0x0000"), Int(0), Int(1)]
-    expr = SetBit(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("base16", "0x0000"), pt.Int(0), pt.Int(1)]
+    expr = pt.SetBit(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0x0000"),
-            TealOp(args[1], Op.int, 0),
-            TealOp(args[2], Op.int, 1),
-            TealOp(expr, Op.setbit),
+            pt.TealOp(args[0], pt.Op.byte, "0x0000"),
+            pt.TealOp(args[1], pt.Op.int, 0),
+            pt.TealOp(args[2], pt.Op.int, 1),
+            pt.TealOp(expr, pt.Op.setbit),
         ]
     )
 
     actual, _ = expr.__teal__(teal3Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal2Options)
 
 
 def test_set_bit_invalid():
-    with pytest.raises(TealTypeError):
-        SetBit(Int(3), Bytes("index"), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.SetBit(pt.Int(3), pt.Bytes("index"), pt.Int(1))
 
-    with pytest.raises(TealTypeError):
-        SetBit(Int(3), Int(0), Bytes("one"))
+    with pytest.raises(pt.TealTypeError):
+        pt.SetBit(pt.Int(3), pt.Int(0), pt.Bytes("one"))
 
-    with pytest.raises(TealTypeError):
-        SetBit(Bytes("base16", "0xFF"), Bytes("index"), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.SetBit(pt.Bytes("base16", "0xFF"), pt.Bytes("index"), pt.Int(1))
 
-    with pytest.raises(TealTypeError):
-        SetBit(Bytes("base16", "0xFF"), Int(0), Bytes("one"))
+    with pytest.raises(pt.TealTypeError):
+        pt.SetBit(pt.Bytes("base16", "0xFF"), pt.Int(0), pt.Bytes("one"))
 
 
 def test_set_byte():
-    args = [Bytes("base16", "0xFF"), Int(0), Int(3)]
-    expr = SetByte(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.bytes
+    args = [pt.Bytes("base16", "0xFF"), pt.Int(0), pt.Int(3)]
+    expr = pt.SetByte(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.byte, "0xFF"),
-            TealOp(args[1], Op.int, 0),
-            TealOp(args[2], Op.int, 3),
-            TealOp(expr, Op.setbyte),
+            pt.TealOp(args[0], pt.Op.byte, "0xFF"),
+            pt.TealOp(args[1], pt.Op.int, 0),
+            pt.TealOp(args[2], pt.Op.int, 3),
+            pt.TealOp(expr, pt.Op.setbyte),
         ]
     )
 
     actual, _ = expr.__teal__(teal3Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal2Options)
 
 
 def test_set_byte_invalid():
-    with pytest.raises(TealTypeError):
-        SetByte(Int(3), Int(0), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.SetByte(pt.Int(3), pt.Int(0), pt.Int(1))
 
-    with pytest.raises(TealTypeError):
-        SetByte(Bytes("base16", "0xFF"), Bytes("index"), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.SetByte(pt.Bytes("base16", "0xFF"), pt.Bytes("index"), pt.Int(1))
 
-    with pytest.raises(TealTypeError):
-        SetByte(Bytes("base16", "0xFF"), Int(0), Bytes("one"))
+    with pytest.raises(pt.TealTypeError):
+        pt.SetByte(pt.Bytes("base16", "0xFF"), pt.Int(0), pt.Bytes("one"))
 
 
 def test_divw():
-    args = [Int(0), Int(90), Int(30)]
-    expr = Divw(args[0], args[1], args[2])
-    assert expr.type_of() == TealType.uint64
+    args = [pt.Int(0), pt.Int(90), pt.Int(30)]
+    expr = pt.Divw(args[0], args[1], args[2])
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(args[0], Op.int, args[0].value),
-            TealOp(args[1], Op.int, args[1].value),
-            TealOp(args[2], Op.int, args[2].value),
-            TealOp(expr, Op.divw),
+            pt.TealOp(args[0], pt.Op.int, args[0].value),
+            pt.TealOp(args[1], pt.Op.int, args[1].value),
+            pt.TealOp(args[2], pt.Op.int, args[2].value),
+            pt.TealOp(expr, pt.Op.divw),
         ]
     )
 
     actual, _ = expr.__teal__(teal6Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_divw_invalid():
-    with pytest.raises(TealTypeError):
-        Divw(Bytes("10"), Int(0), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Divw(pt.Bytes("10"), pt.Int(0), pt.Int(1))
 
-    with pytest.raises(TealTypeError):
-        Divw(Int(10), Bytes("0"), Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Divw(pt.Int(10), pt.Bytes("0"), pt.Int(1))
 
-    with pytest.raises(TealTypeError):
-        Divw(Int(10), Int(0), Bytes("1"))
+    with pytest.raises(pt.TealTypeError):
+        pt.Divw(pt.Int(10), pt.Int(0), pt.Bytes("1"))
diff --git a/pyteal/ast/tmpl_test.py b/pyteal/ast/tmpl_test.py
index 5eb372df2..12973f07a 100644
--- a/pyteal/ast/tmpl_test.py
+++ b/pyteal/ast/tmpl_test.py
@@ -1,18 +1,15 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_tmpl_int():
-    expr = Tmpl.Int("TMPL_AMNT")
-    assert expr.type_of() == TealType.uint64
+    expr = pt.Tmpl.Int("TMPL_AMNT")
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(expr, Op.int, "TMPL_AMNT")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.int, "TMPL_AMNT")])
 
     actual, _ = expr.__teal__(options)
 
@@ -20,15 +17,15 @@ def test_tmpl_int():
 
 
 def test_tmpl_int_invalid():
-    with pytest.raises(TealInputError):
-        Tmpl.Int("whatever")
+    with pytest.raises(pt.TealInputError):
+        pt.Tmpl.Int("whatever")
 
 
 def test_tmpl_bytes():
-    expr = Tmpl.Bytes("TMPL_NOTE")
-    assert expr.type_of() == TealType.bytes
+    expr = pt.Tmpl.Bytes("TMPL_NOTE")
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(expr, Op.byte, "TMPL_NOTE")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.byte, "TMPL_NOTE")])
 
     actual, _ = expr.__teal__(options)
 
@@ -36,15 +33,15 @@ def test_tmpl_bytes():
 
 
 def test_tmpl_bytes_invalid():
-    with pytest.raises(TealInputError):
-        Tmpl.Bytes("whatever")
+    with pytest.raises(pt.TealInputError):
+        pt.Tmpl.Bytes("whatever")
 
 
 def test_tmpl_addr():
-    expr = Tmpl.Addr("TMPL_RECEIVER0")
-    assert expr.type_of() == TealType.bytes
+    expr = pt.Tmpl.Addr("TMPL_RECEIVER0")
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(expr, Op.addr, "TMPL_RECEIVER0")])
+    expected = pt.TealSimpleBlock([pt.TealOp(expr, pt.Op.addr, "TMPL_RECEIVER0")])
 
     actual, _ = expr.__teal__(options)
 
@@ -52,5 +49,5 @@ def test_tmpl_addr():
 
 
 def test_tmpl_addr_invalid():
-    with pytest.raises(TealInputError):
-        Tmpl.Addr("whatever")
+    with pytest.raises(pt.TealInputError):
+        pt.Tmpl.Addr("whatever")
diff --git a/pyteal/ast/txn_test.py b/pyteal/ast/txn_test.py
index 3b7f6d741..eaaf01464 100644
--- a/pyteal/ast/txn_test.py
+++ b/pyteal/ast/txn_test.py
@@ -2,105 +2,102 @@
 
 import pytest
 
-from .. import *
-
-# this is not necessary but mypy complains if it's not included
-from .. import Expr, TxnField, TxnObject, TxnArray, CompileOptions
-
-fieldToMethod: Dict[TxnField, Callable[[TxnObject], Expr]] = {
-    TxnField.sender: lambda txn: txn.sender(),
-    TxnField.fee: lambda txn: txn.fee(),
-    TxnField.first_valid: lambda txn: txn.first_valid(),
-    TxnField.last_valid: lambda txn: txn.last_valid(),
-    TxnField.note: lambda txn: txn.note(),
-    TxnField.lease: lambda txn: txn.lease(),
-    TxnField.receiver: lambda txn: txn.receiver(),
-    TxnField.amount: lambda txn: txn.amount(),
-    TxnField.close_remainder_to: lambda txn: txn.close_remainder_to(),
-    TxnField.vote_pk: lambda txn: txn.vote_pk(),
-    TxnField.selection_pk: lambda txn: txn.selection_pk(),
-    TxnField.vote_first: lambda txn: txn.vote_first(),
-    TxnField.vote_last: lambda txn: txn.vote_last(),
-    TxnField.vote_key_dilution: lambda txn: txn.vote_key_dilution(),
-    TxnField.type: lambda txn: txn.type(),
-    TxnField.type_enum: lambda txn: txn.type_enum(),
-    TxnField.xfer_asset: lambda txn: txn.xfer_asset(),
-    TxnField.asset_amount: lambda txn: txn.asset_amount(),
-    TxnField.asset_sender: lambda txn: txn.asset_sender(),
-    TxnField.asset_receiver: lambda txn: txn.asset_receiver(),
-    TxnField.asset_close_to: lambda txn: txn.asset_close_to(),
-    TxnField.group_index: lambda txn: txn.group_index(),
-    TxnField.tx_id: lambda txn: txn.tx_id(),
-    TxnField.application_id: lambda txn: txn.application_id(),
-    TxnField.on_completion: lambda txn: txn.on_completion(),
-    TxnField.approval_program: lambda txn: txn.approval_program(),
-    TxnField.clear_state_program: lambda txn: txn.clear_state_program(),
-    TxnField.rekey_to: lambda txn: txn.rekey_to(),
-    TxnField.config_asset: lambda txn: txn.config_asset(),
-    TxnField.config_asset_total: lambda txn: txn.config_asset_total(),
-    TxnField.config_asset_decimals: lambda txn: txn.config_asset_decimals(),
-    TxnField.config_asset_default_frozen: lambda txn: txn.config_asset_default_frozen(),
-    TxnField.config_asset_unit_name: lambda txn: txn.config_asset_unit_name(),
-    TxnField.config_asset_name: lambda txn: txn.config_asset_name(),
-    TxnField.config_asset_url: lambda txn: txn.config_asset_url(),
-    TxnField.config_asset_metadata_hash: lambda txn: txn.config_asset_metadata_hash(),
-    TxnField.config_asset_manager: lambda txn: txn.config_asset_manager(),
-    TxnField.config_asset_reserve: lambda txn: txn.config_asset_reserve(),
-    TxnField.config_asset_freeze: lambda txn: txn.config_asset_freeze(),
-    TxnField.config_asset_clawback: lambda txn: txn.config_asset_clawback(),
-    TxnField.freeze_asset: lambda txn: txn.freeze_asset(),
-    TxnField.freeze_asset_account: lambda txn: txn.freeze_asset_account(),
-    TxnField.freeze_asset_frozen: lambda txn: txn.freeze_asset_frozen(),
-    TxnField.global_num_uints: lambda txn: txn.global_num_uints(),
-    TxnField.global_num_byte_slices: lambda txn: txn.global_num_byte_slices(),
-    TxnField.local_num_uints: lambda txn: txn.local_num_uints(),
-    TxnField.local_num_byte_slices: lambda txn: txn.local_num_byte_slices(),
-    TxnField.extra_program_pages: lambda txn: txn.extra_program_pages(),
-    TxnField.nonparticipation: lambda txn: txn.nonparticipation(),
-    TxnField.created_asset_id: lambda txn: txn.created_asset_id(),
-    TxnField.created_application_id: lambda txn: txn.created_application_id(),
-    TxnField.last_log: lambda txn: txn.last_log(),
-    TxnField.state_proof_pk: lambda txn: txn.state_proof_pk(),
+import pyteal as pt
+
+fieldToMethod: Dict[pt.TxnField, Callable[[pt.TxnObject], pt.Expr]] = {
+    pt.TxnField.sender: lambda txn: txn.sender(),
+    pt.TxnField.fee: lambda txn: txn.fee(),
+    pt.TxnField.first_valid: lambda txn: txn.first_valid(),
+    pt.TxnField.last_valid: lambda txn: txn.last_valid(),
+    pt.TxnField.note: lambda txn: txn.note(),
+    pt.TxnField.lease: lambda txn: txn.lease(),
+    pt.TxnField.receiver: lambda txn: txn.receiver(),
+    pt.TxnField.amount: lambda txn: txn.amount(),
+    pt.TxnField.close_remainder_to: lambda txn: txn.close_remainder_to(),
+    pt.TxnField.vote_pk: lambda txn: txn.vote_pk(),
+    pt.TxnField.selection_pk: lambda txn: txn.selection_pk(),
+    pt.TxnField.vote_first: lambda txn: txn.vote_first(),
+    pt.TxnField.vote_last: lambda txn: txn.vote_last(),
+    pt.TxnField.vote_key_dilution: lambda txn: txn.vote_key_dilution(),
+    pt.TxnField.type: lambda txn: txn.type(),
+    pt.TxnField.type_enum: lambda txn: txn.type_enum(),
+    pt.TxnField.xfer_asset: lambda txn: txn.xfer_asset(),
+    pt.TxnField.asset_amount: lambda txn: txn.asset_amount(),
+    pt.TxnField.asset_sender: lambda txn: txn.asset_sender(),
+    pt.TxnField.asset_receiver: lambda txn: txn.asset_receiver(),
+    pt.TxnField.asset_close_to: lambda txn: txn.asset_close_to(),
+    pt.TxnField.group_index: lambda txn: txn.group_index(),
+    pt.TxnField.tx_id: lambda txn: txn.tx_id(),
+    pt.TxnField.application_id: lambda txn: txn.application_id(),
+    pt.TxnField.on_completion: lambda txn: txn.on_completion(),
+    pt.TxnField.approval_program: lambda txn: txn.approval_program(),
+    pt.TxnField.clear_state_program: lambda txn: txn.clear_state_program(),
+    pt.TxnField.rekey_to: lambda txn: txn.rekey_to(),
+    pt.TxnField.config_asset: lambda txn: txn.config_asset(),
+    pt.TxnField.config_asset_total: lambda txn: txn.config_asset_total(),
+    pt.TxnField.config_asset_decimals: lambda txn: txn.config_asset_decimals(),
+    pt.TxnField.config_asset_default_frozen: lambda txn: txn.config_asset_default_frozen(),
+    pt.TxnField.config_asset_unit_name: lambda txn: txn.config_asset_unit_name(),
+    pt.TxnField.config_asset_name: lambda txn: txn.config_asset_name(),
+    pt.TxnField.config_asset_url: lambda txn: txn.config_asset_url(),
+    pt.TxnField.config_asset_metadata_hash: lambda txn: txn.config_asset_metadata_hash(),
+    pt.TxnField.config_asset_manager: lambda txn: txn.config_asset_manager(),
+    pt.TxnField.config_asset_reserve: lambda txn: txn.config_asset_reserve(),
+    pt.TxnField.config_asset_freeze: lambda txn: txn.config_asset_freeze(),
+    pt.TxnField.config_asset_clawback: lambda txn: txn.config_asset_clawback(),
+    pt.TxnField.freeze_asset: lambda txn: txn.freeze_asset(),
+    pt.TxnField.freeze_asset_account: lambda txn: txn.freeze_asset_account(),
+    pt.TxnField.freeze_asset_frozen: lambda txn: txn.freeze_asset_frozen(),
+    pt.TxnField.global_num_uints: lambda txn: txn.global_num_uints(),
+    pt.TxnField.global_num_byte_slices: lambda txn: txn.global_num_byte_slices(),
+    pt.TxnField.local_num_uints: lambda txn: txn.local_num_uints(),
+    pt.TxnField.local_num_byte_slices: lambda txn: txn.local_num_byte_slices(),
+    pt.TxnField.extra_program_pages: lambda txn: txn.extra_program_pages(),
+    pt.TxnField.nonparticipation: lambda txn: txn.nonparticipation(),
+    pt.TxnField.created_asset_id: lambda txn: txn.created_asset_id(),
+    pt.TxnField.created_application_id: lambda txn: txn.created_application_id(),
+    pt.TxnField.last_log: lambda txn: txn.last_log(),
+    pt.TxnField.state_proof_pk: lambda txn: txn.state_proof_pk(),
 }
 
-arrayFieldToProperty: Dict[TxnField, Callable[[TxnObject], TxnArray]] = {
-    TxnField.application_args: lambda txn: txn.application_args,
-    TxnField.accounts: lambda txn: txn.accounts,
-    TxnField.assets: lambda txn: txn.assets,
-    TxnField.applications: lambda txn: txn.applications,
-    TxnField.logs: lambda txn: txn.logs,
+arrayFieldToProperty: Dict[pt.TxnField, Callable[[pt.TxnObject], pt.TxnArray]] = {
+    pt.TxnField.application_args: lambda txn: txn.application_args,
+    pt.TxnField.accounts: lambda txn: txn.accounts,
+    pt.TxnField.assets: lambda txn: txn.assets,
+    pt.TxnField.applications: lambda txn: txn.applications,
+    pt.TxnField.logs: lambda txn: txn.logs,
 }
 
-arrayFieldToLengthField: Dict[TxnField, TxnField] = {
-    TxnField.application_args: TxnField.num_app_args,
-    TxnField.accounts: TxnField.num_accounts,
-    TxnField.assets: TxnField.num_assets,
-    TxnField.applications: TxnField.num_applications,
-    TxnField.logs: TxnField.num_logs,
+arrayFieldToLengthField: Dict[pt.TxnField, pt.TxnField] = {
+    pt.TxnField.application_args: pt.TxnField.num_app_args,
+    pt.TxnField.accounts: pt.TxnField.num_accounts,
+    pt.TxnField.assets: pt.TxnField.num_assets,
+    pt.TxnField.applications: pt.TxnField.num_applications,
+    pt.TxnField.logs: pt.TxnField.num_logs,
 }
 
 
 def test_txn_fields():
-    dynamicGtxnArg = Int(0)
+    dynamicGtxnArg = pt.Int(0)
 
     txnObjects = [
-        (Txn, Op.txn, Op.txna, Op.txnas, [], []),
+        (pt.Txn, pt.Op.txn, pt.Op.txna, pt.Op.txnas, [], []),
         *[
-            (Gtxn[i], Op.gtxn, Op.gtxna, Op.gtxnas, [i], [])
-            for i in range(MAX_GROUP_SIZE)
+            (pt.Gtxn[i], pt.Op.gtxn, pt.Op.gtxna, pt.Op.gtxnas, [i], [])
+            for i in range(pt.MAX_GROUP_SIZE)
         ],
         (
-            Gtxn[dynamicGtxnArg],
-            Op.gtxns,
-            Op.gtxnsa,
-            Op.gtxnsas,
+            pt.Gtxn[dynamicGtxnArg],
+            pt.Op.gtxns,
+            pt.Op.gtxnsa,
+            pt.Op.gtxnsas,
             [],
-            [TealOp(dynamicGtxnArg, Op.int, 0)],
+            [pt.TealOp(dynamicGtxnArg, pt.Op.int, 0)],
         ),
-        (InnerTxn, Op.itxn, Op.itxna, Op.itxnas, [], []),
+        (pt.InnerTxn, pt.Op.itxn, pt.Op.itxna, pt.Op.itxnas, [], []),
         *[
-            (Gitxn[i], Op.gitxn, Op.gitxna, Op.gitxnas, [i], [])
-            for i in range(MAX_GROUP_SIZE)
+            (pt.Gitxn[i], pt.Op.gitxn, pt.Op.gitxna, pt.Op.gitxnas, [i], [])
+            for i in range(pt.MAX_GROUP_SIZE)
         ],
     ]
 
@@ -112,24 +109,24 @@ def test_txn_fields():
         immediateArgsPrefix,
         irPrefix,
     ) in txnObjects:
-        for field in TxnField:
+        for field in pt.TxnField:
             if field.is_array:
                 array = arrayFieldToProperty[field](txnObject)
                 lengthExpr = array.length()
 
                 lengthFieldName = arrayFieldToLengthField[field].arg_name
                 immediateArgs = immediateArgsPrefix + [lengthFieldName]
-                expected = TealSimpleBlock(
-                    irPrefix + [TealOp(lengthExpr, op, *immediateArgs)]
+                expected = pt.TealSimpleBlock(
+                    irPrefix + [pt.TealOp(lengthExpr, op, *immediateArgs)]
                 )
                 expected.addIncoming()
-                expected = TealBlock.NormalizeBlocks(expected)
+                expected = pt.TealBlock.NormalizeBlocks(expected)
 
                 version = max(op.min_version, field.min_version)
 
-                actual, _ = lengthExpr.__teal__(CompileOptions(version=version))
+                actual, _ = lengthExpr.__teal__(pt.CompileOptions(version=version))
                 actual.addIncoming()
-                actual = TealBlock.NormalizeBlocks(actual)
+                actual = pt.TealBlock.NormalizeBlocks(actual)
 
                 assert (
                     actual == expected
@@ -138,24 +135,25 @@ def test_txn_fields():
                 )
 
                 if version > 2:
-                    with pytest.raises(TealInputError):
-                        lengthExpr.__teal__(CompileOptions(version=version - 1))
+                    with pytest.raises(pt.TealInputError):
+                        lengthExpr.__teal__(pt.CompileOptions(version=version - 1))
 
                 for i in range(32):  # just an arbitrary large int
                     elementExpr = array[i]
 
                     immediateArgs = immediateArgsPrefix + [field.arg_name, i]
-                    expected = TealSimpleBlock(
-                        irPrefix + [TealOp(elementExpr, staticArrayOp, *immediateArgs)]
+                    expected = pt.TealSimpleBlock(
+                        irPrefix
+                        + [pt.TealOp(elementExpr, staticArrayOp, *immediateArgs)]
                     )
                     expected.addIncoming()
-                    expected = TealBlock.NormalizeBlocks(expected)
+                    expected = pt.TealBlock.NormalizeBlocks(expected)
 
                     version = max(staticArrayOp.min_version, field.min_version)
 
-                    actual, _ = elementExpr.__teal__(CompileOptions(version=version))
+                    actual, _ = elementExpr.__teal__(pt.CompileOptions(version=version))
                     actual.addIncoming()
-                    actual = TealBlock.NormalizeBlocks(actual)
+                    actual = pt.TealBlock.NormalizeBlocks(actual)
 
                     assert (
                         actual == expected
@@ -164,31 +162,33 @@ def test_txn_fields():
                     )
 
                     if version > 2:
-                        with pytest.raises(TealInputError):
-                            elementExpr.__teal__(CompileOptions(version=version - 1))
+                        with pytest.raises(pt.TealInputError):
+                            elementExpr.__teal__(pt.CompileOptions(version=version - 1))
 
                 if dynamicArrayOp is not None:
-                    dynamicIndex = Int(2)
+                    dynamicIndex = pt.Int(2)
                     dynamicElementExpr = array[dynamicIndex]
 
                     immediateArgs = immediateArgsPrefix + [field.arg_name]
-                    expected = TealSimpleBlock(
+                    expected = pt.TealSimpleBlock(
                         irPrefix
                         + [
-                            TealOp(dynamicIndex, Op.int, 2),
-                            TealOp(dynamicElementExpr, dynamicArrayOp, *immediateArgs),
+                            pt.TealOp(dynamicIndex, pt.Op.int, 2),
+                            pt.TealOp(
+                                dynamicElementExpr, dynamicArrayOp, *immediateArgs
+                            ),
                         ]
                     )
                     expected.addIncoming()
-                    expected = TealBlock.NormalizeBlocks(expected)
+                    expected = pt.TealBlock.NormalizeBlocks(expected)
 
                     version = max(dynamicArrayOp.min_version, field.min_version)
 
                     actual, _ = dynamicElementExpr.__teal__(
-                        CompileOptions(version=version)
+                        pt.CompileOptions(version=version)
                     )
                     actual.addIncoming()
-                    actual = TealBlock.NormalizeBlocks(actual)
+                    actual = pt.TealBlock.NormalizeBlocks(actual)
 
                     assert (
                         actual == expected
@@ -197,9 +197,9 @@ def test_txn_fields():
                     )
 
                     if version > 2:
-                        with pytest.raises(TealInputError):
+                        with pytest.raises(pt.TealInputError):
                             dynamicElementExpr.__teal__(
-                                CompileOptions(version=version - 1)
+                                pt.CompileOptions(version=version - 1)
                             )
 
                 continue
@@ -208,27 +208,29 @@ def test_txn_fields():
                 # ignore length fields since they are checked with their arrays
                 continue
 
-            if field == TxnField.first_valid_time:
-                # ignore first_valid_time since it is not exposed on TxnObject yet
+            if field == pt.TxnField.first_valid_time:
+                # ignore first_valid_time since it is not exposed on pt.TxnObject yet
                 continue
 
             expr = fieldToMethod[field](txnObject)
 
             immediateArgs = immediateArgsPrefix + [field.arg_name]
-            expected = TealSimpleBlock(irPrefix + [TealOp(expr, op, *immediateArgs)])
+            expected = pt.TealSimpleBlock(
+                irPrefix + [pt.TealOp(expr, op, *immediateArgs)]
+            )
             expected.addIncoming()
-            expected = TealBlock.NormalizeBlocks(expected)
+            expected = pt.TealBlock.NormalizeBlocks(expected)
 
             version = max(op.min_version, field.min_version)
 
-            actual, _ = expr.__teal__(CompileOptions(version=version))
+            actual, _ = expr.__teal__(pt.CompileOptions(version=version))
             actual.addIncoming()
-            actual = TealBlock.NormalizeBlocks(actual)
+            actual = pt.TealBlock.NormalizeBlocks(actual)
 
             assert actual == expected, "{}: field {} does not match expected".format(
                 op, field
             )
 
             if version > 2:
-                with pytest.raises(TealInputError):
-                    expr.__teal__(CompileOptions(version=version - 1))
+                with pytest.raises(pt.TealInputError):
+                    expr.__teal__(pt.CompileOptions(version=version - 1))
diff --git a/pyteal/ast/unaryexpr_test.py b/pyteal/ast/unaryexpr_test.py
index 26213e3f5..50a6e2f15 100644
--- a/pyteal/ast/unaryexpr_test.py
+++ b/pyteal/ast/unaryexpr_test.py
@@ -1,423 +1,451 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-teal2Options = CompileOptions(version=2)
-teal3Options = CompileOptions(version=3)
-teal4Options = CompileOptions(version=4)
-teal5Options = CompileOptions(version=5)
-teal6Options = CompileOptions(version=6)
+teal2Options = pt.CompileOptions(version=2)
+teal3Options = pt.CompileOptions(version=3)
+teal4Options = pt.CompileOptions(version=4)
+teal5Options = pt.CompileOptions(version=5)
+teal6Options = pt.CompileOptions(version=6)
 
 
 def test_btoi():
-    arg = Arg(1)
-    expr = Btoi(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Arg(1)
+    expr = pt.Btoi(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.arg, 1), TealOp(expr, Op.btoi)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.arg, 1), pt.TealOp(expr, pt.Op.btoi)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_btoi_invalid():
-    with pytest.raises(TealTypeError):
-        Btoi(Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Btoi(pt.Int(1))
 
 
 def test_itob():
-    arg = Int(1)
-    expr = Itob(arg)
-    assert expr.type_of() == TealType.bytes
+    arg = pt.Int(1)
+    expr = pt.Itob(arg)
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 1), TealOp(expr, Op.itob)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 1), pt.TealOp(expr, pt.Op.itob)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_itob_invalid():
-    with pytest.raises(TealTypeError):
-        Itob(Arg(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Itob(pt.Arg(1))
 
 
 def test_len():
-    arg = Txn.receiver()
-    expr = Len(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Txn.receiver()
+    expr = pt.Len(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.txn, "Receiver"), TealOp(expr, Op.len)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.txn, "Receiver"), pt.TealOp(expr, pt.Op.len)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_len_invalid():
-    with pytest.raises(TealTypeError):
-        Len(Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Len(pt.Int(1))
 
 
 def test_bitlen_int():
-    arg = Int(7)
-    expr = BitLen(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(7)
+    expr = pt.BitLen(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 7), TealOp(expr, Op.bitlen)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 7), pt.TealOp(expr, pt.Op.bitlen)]
+    )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_bitlen_bytes():
-    arg = Txn.receiver()
-    expr = BitLen(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Txn.receiver()
+    expr = pt.BitLen(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(arg, Op.txn, "Receiver"), TealOp(expr, Op.bitlen)]
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.txn, "Receiver"), pt.TealOp(expr, pt.Op.bitlen)]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_sha256():
-    arg = Arg(0)
-    expr = Sha256(arg)
-    assert expr.type_of() == TealType.bytes
+    arg = pt.Arg(0)
+    expr = pt.Sha256(arg)
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(arg, Op.arg, 0), TealOp(expr, Op.sha256)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.arg, 0), pt.TealOp(expr, pt.Op.sha256)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_sha256_invalid():
-    with pytest.raises(TealTypeError):
-        Sha256(Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Sha256(pt.Int(1))
 
 
 def test_sha512_256():
-    arg = Arg(0)
-    expr = Sha512_256(arg)
-    assert expr.type_of() == TealType.bytes
+    arg = pt.Arg(0)
+    expr = pt.Sha512_256(arg)
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(arg, Op.arg, 0), TealOp(expr, Op.sha512_256)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.arg, 0), pt.TealOp(expr, pt.Op.sha512_256)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_sha512_256_invalid():
-    with pytest.raises(TealTypeError):
-        Sha512_256(Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Sha512_256(pt.Int(1))
 
 
 def test_keccak256():
-    arg = Arg(0)
-    expr = Keccak256(arg)
-    assert expr.type_of() == TealType.bytes
+    arg = pt.Arg(0)
+    expr = pt.Keccak256(arg)
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(arg, Op.arg, 0), TealOp(expr, Op.keccak256)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.arg, 0), pt.TealOp(expr, pt.Op.keccak256)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_keccak256_invalid():
-    with pytest.raises(TealTypeError):
-        Keccak256(Int(1))
+    with pytest.raises(pt.TealTypeError):
+        pt.Keccak256(pt.Int(1))
 
 
 def test_not():
-    arg = Int(1)
-    expr = Not(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(1)
+    expr = pt.Not(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 1), TealOp(expr, Op.logic_not)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 1), pt.TealOp(expr, pt.Op.logic_not)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_not_invalid():
-    with pytest.raises(TealTypeError):
-        Not(Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Not(pt.Txn.receiver())
 
 
 def test_bitwise_not():
-    arg = Int(2)
-    expr = BitwiseNot(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(2)
+    expr = pt.BitwiseNot(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 2), TealOp(expr, Op.bitwise_not)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 2), pt.TealOp(expr, pt.Op.bitwise_not)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_bitwise_not_overload():
-    arg = Int(10)
+    arg = pt.Int(10)
     expr = ~arg
-    assert expr.type_of() == TealType.uint64
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 10), TealOp(expr, Op.bitwise_not)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 10), pt.TealOp(expr, pt.Op.bitwise_not)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_bitwise_not_invalid():
-    with pytest.raises(TealTypeError):
-        BitwiseNot(Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.BitwiseNot(pt.Txn.receiver())
 
 
 def test_sqrt():
-    arg = Int(4)
-    expr = Sqrt(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(4)
+    expr = pt.Sqrt(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 4), TealOp(expr, Op.sqrt)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 4), pt.TealOp(expr, pt.Op.sqrt)]
+    )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_sqrt_invalid():
-    with pytest.raises(TealTypeError):
-        Sqrt(Txn.receiver())
+    with pytest.raises(pt.TealTypeError):
+        pt.Sqrt(pt.Txn.receiver())
 
 
 def test_pop():
-    arg_int = Int(3)
-    expr_int = Pop(arg_int)
-    assert expr_int.type_of() == TealType.none
+    arg_int = pt.Int(3)
+    expr_int = pt.Pop(arg_int)
+    assert expr_int.type_of() == pt.TealType.none
 
-    expected_int = TealSimpleBlock(
-        [TealOp(arg_int, Op.int, 3), TealOp(expr_int, Op.pop)]
+    expected_int = pt.TealSimpleBlock(
+        [pt.TealOp(arg_int, pt.Op.int, 3), pt.TealOp(expr_int, pt.Op.pop)]
     )
 
     actual_int, _ = expr_int.__teal__(teal2Options)
     actual_int.addIncoming()
-    actual_int = TealBlock.NormalizeBlocks(actual_int)
+    actual_int = pt.TealBlock.NormalizeBlocks(actual_int)
 
     assert actual_int == expected_int
 
-    arg_bytes = Txn.receiver()
-    expr_bytes = Pop(arg_bytes)
-    assert expr_bytes.type_of() == TealType.none
+    arg_bytes = pt.Txn.receiver()
+    expr_bytes = pt.Pop(arg_bytes)
+    assert expr_bytes.type_of() == pt.TealType.none
 
-    expected_bytes = TealSimpleBlock(
-        [TealOp(arg_bytes, Op.txn, "Receiver"), TealOp(expr_bytes, Op.pop)]
+    expected_bytes = pt.TealSimpleBlock(
+        [pt.TealOp(arg_bytes, pt.Op.txn, "Receiver"), pt.TealOp(expr_bytes, pt.Op.pop)]
     )
 
     actual_bytes, _ = expr_bytes.__teal__(teal2Options)
     actual_bytes.addIncoming()
-    actual_bytes = TealBlock.NormalizeBlocks(actual_bytes)
+    actual_bytes = pt.TealBlock.NormalizeBlocks(actual_bytes)
 
     assert actual_bytes == expected_bytes
 
 
 def test_pop_invalid():
-    expr = Pop(Int(0))
-    with pytest.raises(TealTypeError):
-        Pop(expr)
+    expr = pt.Pop(pt.Int(0))
+    with pytest.raises(pt.TealTypeError):
+        pt.Pop(expr)
 
 
 def test_balance():
-    arg = Int(0)
-    expr = Balance(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(0)
+    expr = pt.Balance(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 0), TealOp(expr, Op.balance)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 0), pt.TealOp(expr, pt.Op.balance)]
+    )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_balance_direct_ref():
-    arg = Txn.sender()
-    expr = Balance(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Txn.sender()
+    expr = pt.Balance(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(arg, Op.txn, "Sender"), TealOp(expr, Op.balance)]
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.txn, "Sender"), pt.TealOp(expr, pt.Op.balance)]
     )
 
     actual, _ = expr.__teal__(teal2Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_balance_invalid():
-    with pytest.raises(TealTypeError):
-        args = [Txn.sender(), Int(17)]
-        expr = AssetHolding.balance(args[0], args[1])
-        MinBalance(expr)
+    with pytest.raises(pt.TealTypeError):
+        args = [pt.Txn.sender(), pt.Int(17)]
+        expr = pt.AssetHolding.balance(args[0], args[1])
+        pt.MinBalance(expr)
 
 
 def test_min_balance():
-    arg = Int(0)
-    expr = MinBalance(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Int(0)
+    expr = pt.MinBalance(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 0), TealOp(expr, Op.min_balance)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 0), pt.TealOp(expr, pt.Op.min_balance)]
+    )
 
     actual, _ = expr.__teal__(teal3Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_min_balance_direct_ref():
-    arg = Txn.sender()
-    expr = MinBalance(arg)
-    assert expr.type_of() == TealType.uint64
+    arg = pt.Txn.sender()
+    expr = pt.MinBalance(arg)
+    assert expr.type_of() == pt.TealType.uint64
 
-    expected = TealSimpleBlock(
-        [TealOp(arg, Op.txn, "Sender"), TealOp(expr, Op.min_balance)]
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.txn, "Sender"), pt.TealOp(expr, pt.Op.min_balance)]
     )
 
     actual, _ = expr.__teal__(teal3Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_min_balance_invalid():
-    with pytest.raises(TealTypeError):
-        args = [Txn.sender(), Int(17)]
-        expr = AssetHolding.balance(args[0], args[1])
-        MinBalance(expr)
+    with pytest.raises(pt.TealTypeError):
+        args = [pt.Txn.sender(), pt.Int(17)]
+        expr = pt.AssetHolding.balance(args[0], args[1])
+        pt.MinBalance(expr)
 
 
 def test_b_not():
-    arg = Bytes("base16", "0xFFFFFFFFFFFFFFFFFF")
-    expr = BytesNot(arg)
-    assert expr.type_of() == TealType.bytes
-
-    expected = TealSimpleBlock(
-        [TealOp(arg, Op.byte, "0xFFFFFFFFFFFFFFFFFF"), TealOp(expr, Op.b_not)]
+    arg = pt.Bytes("base16", "0xFFFFFFFFFFFFFFFFFF")
+    expr = pt.BytesNot(arg)
+    assert expr.type_of() == pt.TealType.bytes
+
+    expected = pt.TealSimpleBlock(
+        [
+            pt.TealOp(arg, pt.Op.byte, "0xFFFFFFFFFFFFFFFFFF"),
+            pt.TealOp(expr, pt.Op.b_not),
+        ]
     )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_b_not_invalid():
-    with pytest.raises(TealTypeError):
-        BytesNot(Int(2))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesNot(pt.Int(2))
 
 
 def test_bsqrt():
-    arg = Bytes("base16", "0xFEDCBA9876543210")
-    expr = BytesSqrt(arg)
-    assert expr.type_of() == TealType.bytes
+    arg = pt.Bytes("base16", "0xFEDCBA9876543210")
+    expr = pt.BytesSqrt(arg)
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock(
-        [TealOp(arg, Op.byte, "0xFEDCBA9876543210"), TealOp(expr, Op.bsqrt)]
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.byte, "0xFEDCBA9876543210"), pt.TealOp(expr, pt.Op.bsqrt)]
     )
 
     actual, _ = expr.__teal__(teal6Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_bsqrt_invalid():
-    with pytest.raises(TealTypeError):
-        BytesSqrt(Int(2**64 - 1))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesSqrt(pt.Int(2**64 - 1))
 
 
 def test_b_zero():
-    arg = Int(8)
-    expr = BytesZero(arg)
-    assert expr.type_of() == TealType.bytes
+    arg = pt.Int(8)
+    expr = pt.BytesZero(arg)
+    assert expr.type_of() == pt.TealType.bytes
 
-    expected = TealSimpleBlock([TealOp(arg, Op.int, 8), TealOp(expr, Op.bzero)])
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.int, 8), pt.TealOp(expr, pt.Op.bzero)]
+    )
 
     actual, _ = expr.__teal__(teal4Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
 
 def test_b_zero_invalid():
-    with pytest.raises(TealTypeError):
-        BytesZero(Bytes("base16", "0x11"))
+    with pytest.raises(pt.TealTypeError):
+        pt.BytesZero(pt.Bytes("base16", "0x11"))
 
 
 def test_log():
-    arg = Bytes("message")
-    expr = Log(arg)
-    assert expr.type_of() == TealType.none
+    arg = pt.Bytes("message")
+    expr = pt.Log(arg)
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
-    expected = TealSimpleBlock(
-        [TealOp(arg, Op.byte, '"message"'), TealOp(expr, Op.log)]
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg, pt.Op.byte, '"message"'), pt.TealOp(expr, pt.Op.log)]
     )
 
     actual, _ = expr.__teal__(teal5Options)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
 
     assert actual == expected
 
-    with pytest.raises(TealInputError):
+    with pytest.raises(pt.TealInputError):
         expr.__teal__(teal4Options)
 
 
 def test_log_invalid():
-    with pytest.raises(TealTypeError):
-        Log(Int(7))
+    with pytest.raises(pt.TealTypeError):
+        pt.Log(pt.Int(7))
diff --git a/pyteal/ast/while_test.py b/pyteal/ast/while_test.py
index ff539a046..0fdf909de 100644
--- a/pyteal/ast/while_test.py
+++ b/pyteal/ast/while_test.py
@@ -1,48 +1,47 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_while_compiles():
 
-    i = ScratchVar()
-    expr = While(Int(2)).Do(Seq([i.store(Int(0))]))
-    assert expr.type_of() == TealType.none
+    i = pt.ScratchVar()
+    expr = pt.While(pt.Int(2)).Do(pt.Seq([i.store(pt.Int(0))]))
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
     expr.__teal__(options)
 
 
 def test_nested_whiles_compile():
-    i = ScratchVar()
-    expr = While(Int(2)).Do(Seq([While(Int(2)).Do(Seq([i.store(Int(0))]))]))
-    assert expr.type_of() == TealType.none
+    i = pt.ScratchVar()
+    expr = pt.While(pt.Int(2)).Do(
+        pt.Seq([pt.While(pt.Int(2)).Do(pt.Seq([i.store(pt.Int(0))]))])
+    )
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
 
 def test_continue_break():
-    expr = While(Int(0)).Do(Seq([If(Int(1), Break(), Continue())]))
-    assert expr.type_of() == TealType.none
+    expr = pt.While(pt.Int(0)).Do(pt.Seq([pt.If(pt.Int(1), pt.Break(), pt.Continue())]))
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
     expr.__teal__(options)
 
 
 def test_while():
-    i = ScratchVar()
-    i.store(Int(0))
-    items = [i.load() < Int(2), [i.store(i.load() + Int(1))]]
-    expr = While(items[0]).Do(Seq(items[1]))
-    assert expr.type_of() == TealType.none
+    i = pt.ScratchVar()
+    i.store(pt.Int(0))
+    items = [i.load() < pt.Int(2), [i.store(i.load() + pt.Int(1))]]
+    expr = pt.While(items[0]).Do(pt.Seq(items[1]))
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
     expected, condEnd = items[0].__teal__(options)
-    do, doEnd = Seq(items[1]).__teal__(options)
-    expectedBranch = TealConditionalBlock([])
-    end = TealSimpleBlock([])
+    do, doEnd = pt.Seq(items[1]).__teal__(options)
+    expectedBranch = pt.TealConditionalBlock([])
+    end = pt.TealSimpleBlock([])
 
     expectedBranch.setTrueBlock(do)
     expectedBranch.setFalseBlock(end)
@@ -54,23 +53,23 @@ def test_while():
 
 
 def test_while_continue():
-    i = ScratchVar()
-    i.store(Int(0))
+    i = pt.ScratchVar()
+    i.store(pt.Int(0))
     items = [
-        i.load() < Int(2),
-        i.store(i.load() + Int(1)),
-        If(i.load() == Int(1), Continue()),
+        i.load() < pt.Int(2),
+        i.store(i.load() + pt.Int(1)),
+        pt.If(i.load() == pt.Int(1), pt.Continue()),
     ]
-    expr = While(items[0]).Do(Seq(items[1], items[2]))
-    assert expr.type_of() == TealType.none
+    expr = pt.While(items[0]).Do(pt.Seq(items[1], items[2]))
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
     options.enterLoop()
 
     expected, condEnd = items[0].__teal__(options)
-    do, doEnd = Seq([items[1], items[2]]).__teal__(options)
-    expectedBranch = TealConditionalBlock([])
-    end = TealSimpleBlock([])
+    do, doEnd = pt.Seq([items[1], items[2]]).__teal__(options)
+    expectedBranch = pt.TealConditionalBlock([])
+    end = pt.TealSimpleBlock([])
 
     expectedBranch.setTrueBlock(do)
     expectedBranch.setFalseBlock(end)
@@ -88,23 +87,23 @@ def test_while_continue():
 
 
 def test_while_break():
-    i = ScratchVar()
-    i.store(Int(0))
+    i = pt.ScratchVar()
+    i.store(pt.Int(0))
     items = [
-        i.load() < Int(2),
-        i.store(i.load() + Int(1)),
-        If(i.load() == Int(1), Break()),
+        i.load() < pt.Int(2),
+        i.store(i.load() + pt.Int(1)),
+        pt.If(i.load() == pt.Int(1), pt.Break()),
     ]
-    expr = While(items[0]).Do(Seq(items[1], items[2]))
-    assert expr.type_of() == TealType.none
+    expr = pt.While(items[0]).Do(pt.Seq(items[1], items[2]))
+    assert expr.type_of() == pt.TealType.none
     assert not expr.has_return()
 
     options.enterLoop()
 
     expected, condEnd = items[0].__teal__(options)
-    do, doEnd = Seq([items[1], items[2]]).__teal__(options)
-    expectedBranch = TealConditionalBlock([])
-    end = TealSimpleBlock([])
+    do, doEnd = pt.Seq([items[1], items[2]]).__teal__(options)
+    expectedBranch = pt.TealConditionalBlock([])
+    end = pt.TealSimpleBlock([])
 
     expectedBranch.setTrueBlock(do)
     expectedBranch.setFalseBlock(end)
@@ -124,28 +123,28 @@ def test_while_break():
 def test_while_invalid():
 
     with pytest.raises(TypeError):
-        expr = While()
+        expr = pt.While()
 
-    with pytest.raises(TealCompileError):
-        expr = While(Int(2))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.While(pt.Int(2))
         expr.type_of()
 
-    with pytest.raises(TealCompileError):
-        expr = While(Int(2))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.While(pt.Int(2))
         expr.__teal__(options)
 
-    with pytest.raises(TealCompileError):
-        expr = While(Int(2))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.While(pt.Int(2))
         expr.type_of()
 
-    with pytest.raises(TealCompileError):
-        expr = While(Int(2))
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.While(pt.Int(2))
         expr.__str__()
 
-    with pytest.raises(TealTypeError):
-        expr = While(Int(2)).Do(Int(2))
+    with pytest.raises(pt.TealTypeError):
+        expr = pt.While(pt.Int(2)).Do(pt.Int(2))
         expr.__str__()
 
-    with pytest.raises(TealCompileError):
-        expr = While(Int(0)).Do(Continue()).Do(Continue())
+    with pytest.raises(pt.TealCompileError):
+        expr = pt.While(pt.Int(0)).Do(pt.Continue()).Do(pt.Continue())
         expr.__str__()
diff --git a/pyteal/compiler/compiler_test.py b/pyteal/compiler/compiler_test.py
index 74b5799b5..24f30dc18 100644
--- a/pyteal/compiler/compiler_test.py
+++ b/pyteal/compiler/compiler_test.py
@@ -1,28 +1,25 @@
 import pytest
 
-from .. import *
-
-# this is not necessary but mypy complains if it's not included
-from ..ast import *
+import pyteal as pt
 
 
 def test_compile_single():
-    expr = Int(1)
+    expr = pt.Int(1)
 
     expected = """
 #pragma version 2
 int 1
 return
 """.strip()
-    actual_application = compileTeal(expr, Mode.Application)
-    actual_signature = compileTeal(expr, Mode.Signature)
+    actual_application = pt.compileTeal(expr, pt.Mode.Application)
+    actual_signature = pt.compileTeal(expr, pt.Mode.Signature)
 
     assert actual_application == actual_signature
     assert actual_application == expected
 
 
 def test_compile_sequence():
-    expr = Seq([Pop(Int(1)), Pop(Int(2)), Int(3) + Int(4)])
+    expr = pt.Seq([pt.Pop(pt.Int(1)), pt.Pop(pt.Int(2)), pt.Int(3) + pt.Int(4)])
 
     expected = """
 #pragma version 2
@@ -35,15 +32,15 @@ def test_compile_sequence():
 +
 return
 """.strip()
-    actual_application = compileTeal(expr, Mode.Application)
-    actual_signature = compileTeal(expr, Mode.Signature)
+    actual_application = pt.compileTeal(expr, pt.Mode.Application)
+    actual_signature = pt.compileTeal(expr, pt.Mode.Signature)
 
     assert actual_application == actual_signature
     assert actual_application == expected
 
 
 def test_compile_branch():
-    expr = If(Int(1)).Then(Int(2)).Else(Int(3))
+    expr = pt.If(pt.Int(1)).Then(pt.Int(2)).Else(pt.Int(3))
 
     expected = """
 #pragma version 2
@@ -56,15 +53,21 @@ def test_compile_branch():
 main_l3:
 return
 """.strip()
-    actual_application = compileTeal(expr, Mode.Application)
-    actual_signature = compileTeal(expr, Mode.Signature)
+    actual_application = pt.compileTeal(expr, pt.Mode.Application)
+    actual_signature = pt.compileTeal(expr, pt.Mode.Signature)
 
     assert actual_application == actual_signature
     assert actual_application == expected
 
 
 def test_compile_branch_multiple():
-    expr = If(Int(1)).Then(Int(2)).ElseIf(Int(3)).Then(Int(4)).Else(Int(5))
+    expr = (
+        pt.If(pt.Int(1))
+        .Then(pt.Int(2))
+        .ElseIf(pt.Int(3))
+        .Then(pt.Int(4))
+        .Else(pt.Int(5))
+    )
 
     expected = """
 #pragma version 2
@@ -82,18 +85,18 @@ def test_compile_branch_multiple():
 main_l5:
 return
 """.strip()
-    actual_application = compileTeal(expr, Mode.Application)
-    actual_signature = compileTeal(expr, Mode.Signature)
+    actual_application = pt.compileTeal(expr, pt.Mode.Application)
+    actual_signature = pt.compileTeal(expr, pt.Mode.Signature)
 
     assert actual_application == actual_signature
     assert actual_application == expected
 
 
 def test_empty_branch():
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.application_id() == Int(0)).Then(Seq()),
-            Approve(),
+            pt.If(pt.Txn.application_id() == pt.Int(0)).Then(pt.Seq()),
+            pt.Approve(),
         ]
     )
 
@@ -106,12 +109,14 @@ def test_empty_branch():
 int 1
 return
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=5, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=5, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_mode():
-    expr = App.globalGet(Bytes("key"))
+    expr = pt.App.globalGet(pt.Bytes("key"))
 
     expected = """
 #pragma version 2
@@ -119,128 +124,128 @@ def test_compile_mode():
 app_global_get
 return
 """.strip()
-    actual_application = compileTeal(expr, Mode.Application)
+    actual_application = pt.compileTeal(expr, pt.Mode.Application)
 
     assert actual_application == expected
 
-    with pytest.raises(TealInputError):
-        compileTeal(expr, Mode.Signature)
+    with pytest.raises(pt.TealInputError):
+        pt.compileTeal(expr, pt.Mode.Signature)
 
 
 def test_compile_version_invalid():
-    expr = Int(1)
+    expr = pt.Int(1)
 
-    with pytest.raises(TealInputError):
-        compileTeal(expr, Mode.Signature, version=1)  # too small
+    with pytest.raises(pt.TealInputError):
+        pt.compileTeal(expr, pt.Mode.Signature, version=1)  # too small
 
-    with pytest.raises(TealInputError):
-        compileTeal(expr, Mode.Signature, version=7)  # too large
+    with pytest.raises(pt.TealInputError):
+        pt.compileTeal(expr, pt.Mode.Signature, version=7)  # too large
 
-    with pytest.raises(TealInputError):
-        compileTeal(expr, Mode.Signature, version=2.0)  # decimal
+    with pytest.raises(pt.TealInputError):
+        pt.compileTeal(expr, pt.Mode.Signature, version=2.0)  # decimal
 
 
 def test_compile_version_2():
-    expr = Int(1)
+    expr = pt.Int(1)
 
     expected = """
 #pragma version 2
 int 1
 return
 """.strip()
-    actual = compileTeal(expr, Mode.Signature, version=2)
+    actual = pt.compileTeal(expr, pt.Mode.Signature, version=2)
     assert actual == expected
 
 
 def test_compile_version_default():
-    expr = Int(1)
+    expr = pt.Int(1)
 
-    actual_default = compileTeal(expr, Mode.Signature)
-    actual_version_2 = compileTeal(expr, Mode.Signature, version=2)
+    actual_default = pt.compileTeal(expr, pt.Mode.Signature)
+    actual_version_2 = pt.compileTeal(expr, pt.Mode.Signature, version=2)
     assert actual_default == actual_version_2
 
 
 def test_compile_version_3():
-    expr = Int(1)
+    expr = pt.Int(1)
 
     expected = """
 #pragma version 3
 int 1
 return
 """.strip()
-    actual = compileTeal(expr, Mode.Signature, version=3)
+    actual = pt.compileTeal(expr, pt.Mode.Signature, version=3)
     assert actual == expected
 
 
 def test_compile_version_4():
-    expr = Int(1)
+    expr = pt.Int(1)
 
     expected = """
 #pragma version 4
 int 1
 return
 """.strip()
-    actual = compileTeal(expr, Mode.Signature, version=4)
+    actual = pt.compileTeal(expr, pt.Mode.Signature, version=4)
     assert actual == expected
 
 
 def test_compile_version_5():
-    expr = Int(1)
+    expr = pt.Int(1)
     expected = """
 #pragma version 5
 int 1
 return
 """.strip()
-    actual = compileTeal(expr, Mode.Signature, version=5)
+    actual = pt.compileTeal(expr, pt.Mode.Signature, version=5)
     assert actual == expected
 
 
 def test_compile_version_6():
-    expr = Int(1)
+    expr = pt.Int(1)
     expected = """
 #pragma version 6
 int 1
 return
 """.strip()
-    actual = compileTeal(expr, Mode.Signature, version=6)
+    actual = pt.compileTeal(expr, pt.Mode.Signature, version=6)
     assert actual == expected
 
 
 def test_slot_load_before_store():
 
-    program = AssetHolding.balance(Int(0), Int(0)).value()
-    with pytest.raises(TealInternalError):
-        compileTeal(program, Mode.Application, version=2)
+    program = pt.AssetHolding.balance(pt.Int(0), pt.Int(0)).value()
+    with pytest.raises(pt.TealInternalError):
+        pt.compileTeal(program, pt.Mode.Application, version=2)
 
-    program = AssetHolding.balance(Int(0), Int(0)).hasValue()
-    with pytest.raises(TealInternalError):
-        compileTeal(program, Mode.Application, version=2)
+    program = pt.AssetHolding.balance(pt.Int(0), pt.Int(0)).hasValue()
+    with pytest.raises(pt.TealInternalError):
+        pt.compileTeal(program, pt.Mode.Application, version=2)
 
-    program = App.globalGetEx(Int(0), Bytes("key")).value()
-    with pytest.raises(TealInternalError):
-        compileTeal(program, Mode.Application, version=2)
+    program = pt.App.globalGetEx(pt.Int(0), pt.Bytes("key")).value()
+    with pytest.raises(pt.TealInternalError):
+        pt.compileTeal(program, pt.Mode.Application, version=2)
 
-    program = App.globalGetEx(Int(0), Bytes("key")).hasValue()
-    with pytest.raises(TealInternalError):
-        compileTeal(program, Mode.Application, version=2)
+    program = pt.App.globalGetEx(pt.Int(0), pt.Bytes("key")).hasValue()
+    with pytest.raises(pt.TealInternalError):
+        pt.compileTeal(program, pt.Mode.Application, version=2)
 
-    program = ScratchVar().load()
-    with pytest.raises(TealInternalError):
-        compileTeal(program, Mode.Application, version=2)
+    program = pt.ScratchVar().load()
+    with pytest.raises(pt.TealInternalError):
+        pt.compileTeal(program, pt.Mode.Application, version=2)
 
 
 def test_assign_scratch_slots():
-    myScratch = ScratchVar(TealType.uint64)
-    otherScratch = ScratchVar(TealType.uint64, 1)
-    anotherScratch = ScratchVar(TealType.uint64, 0)
-    lastScratch = ScratchVar(TealType.uint64)
-    prog = Seq(
+    myScratch = pt.ScratchVar(pt.TealType.uint64)
+    otherScratch = pt.ScratchVar(pt.TealType.uint64, 1)
+    anotherScratch = pt.ScratchVar(pt.TealType.uint64, 0)
+    lastScratch = pt.ScratchVar(pt.TealType.uint64)
+    prog = pt.Seq(
         [
-            myScratch.store(Int(5)),  # Slot 2
-            otherScratch.store(Int(0)),  # Slot 1
-            anotherScratch.store(Int(7)),  # Slot 0
-            lastScratch.store(Int(9)),  # Slot 3
-            Approve(),
+            myScratch.store(pt.Int(5)),  # Slot 2
+            otherScratch.store(pt.Int(0)),  # Slot 1
+            anotherScratch.store(pt.Int(7)),  # Slot 0
+            lastScratch.store(pt.Int(9)),  # Slot 3
+            pt.Approve(),
         ]
     )
 
@@ -257,21 +262,21 @@ def test_assign_scratch_slots():
 int 1
 return
 """.strip()
-    actual = compileTeal(prog, mode=Mode.Signature, version=4)
+    actual = pt.compileTeal(prog, mode=pt.Mode.Signature, version=4)
     assert actual == expected
 
 
 def test_scratchvar_double_assign_invalid():
-    myvar = ScratchVar(TealType.uint64, 10)
-    otherVar = ScratchVar(TealType.uint64, 10)
-    prog = Seq([myvar.store(Int(5)), otherVar.store(Int(0)), Approve()])
-    with pytest.raises(TealInternalError):
-        compileTeal(prog, mode=Mode.Signature, version=4)
+    myvar = pt.ScratchVar(pt.TealType.uint64, 10)
+    otherVar = pt.ScratchVar(pt.TealType.uint64, 10)
+    prog = pt.Seq([myvar.store(pt.Int(5)), otherVar.store(pt.Int(0)), pt.Approve()])
+    with pytest.raises(pt.TealInternalError):
+        pt.compileTeal(prog, mode=pt.Mode.Signature, version=4)
 
 
 def test_assembleConstants():
-    program = Itob(Int(1) + Int(1) + Tmpl.Int("TMPL_VAR")) == Concat(
-        Bytes("test"), Bytes("test"), Bytes("test2")
+    program = pt.Itob(pt.Int(1) + pt.Int(1) + pt.Tmpl.Int("TMPL_VAR")) == pt.Concat(
+        pt.Bytes("test"), pt.Bytes("test"), pt.Bytes("test2")
     )
 
     expectedNoAssemble = """
@@ -290,8 +295,8 @@ def test_assembleConstants():
 ==
 return
 """.strip()
-    actualNoAssemble = compileTeal(
-        program, Mode.Application, version=3, assembleConstants=False
+    actualNoAssemble = pt.compileTeal(
+        program, pt.Mode.Application, version=3, assembleConstants=False
     )
     assert expectedNoAssemble == actualNoAssemble
 
@@ -313,22 +318,22 @@ def test_assembleConstants():
 ==
 return
 """.strip()
-    actualAssemble = compileTeal(
-        program, Mode.Application, version=3, assembleConstants=True
+    actualAssemble = pt.compileTeal(
+        program, pt.Mode.Application, version=3, assembleConstants=True
     )
     assert expectedAssemble == actualAssemble
 
-    with pytest.raises(TealInternalError):
-        compileTeal(program, Mode.Application, version=2, assembleConstants=True)
+    with pytest.raises(pt.TealInternalError):
+        pt.compileTeal(program, pt.Mode.Application, version=2, assembleConstants=True)
 
 
 def test_compile_while():
-    i = ScratchVar()
-    program = Seq(
+    i = pt.ScratchVar()
+    program = pt.Seq(
         [
-            i.store(Int(0)),
-            While(i.load() < Int(2)).Do(Seq([i.store(i.load() + Int(1))])),
-            Approve(),
+            i.store(pt.Int(0)),
+            pt.While(i.load() < pt.Int(2)).Do(pt.Seq([i.store(i.load() + pt.Int(1))])),
+            pt.Approve(),
         ]
     )
 
@@ -350,26 +355,30 @@ def test_compile_while():
 int 1
 return
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
     # nested
-    i = ScratchVar()
-    j = ScratchVar()
+    i = pt.ScratchVar()
+    j = pt.ScratchVar()
 
-    program = Seq(
+    program = pt.Seq(
         [
-            i.store(Int(0)),
-            While(i.load() < Int(2)).Do(
-                Seq(
+            i.store(pt.Int(0)),
+            pt.While(i.load() < pt.Int(2)).Do(
+                pt.Seq(
                     [
-                        j.store(Int(0)),
-                        While(j.load() < Int(5)).Do(Seq([j.store(j.load() + Int(1))])),
-                        i.store(i.load() + Int(1)),
+                        j.store(pt.Int(0)),
+                        pt.While(j.load() < pt.Int(5)).Do(
+                            pt.Seq([j.store(j.load() + pt.Int(1))])
+                        ),
+                        i.store(i.load() + pt.Int(1)),
                     ]
                 )
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -404,18 +413,20 @@ def test_compile_while():
 return
     """.strip()
 
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
 
 def test_compile_for():
-    i = ScratchVar()
-    program = Seq(
+    i = pt.ScratchVar()
+    program = pt.Seq(
         [
-            For(i.store(Int(0)), i.load() < Int(10), i.store(i.load() + Int(1))).Do(
-                Seq([App.globalPut(Itob(i.load()), i.load() * Int(2))])
-            ),
-            Approve(),
+            pt.For(
+                i.store(pt.Int(0)), i.load() < pt.Int(10), i.store(i.load() + pt.Int(1))
+            ).Do(pt.Seq([pt.App.globalPut(pt.Itob(i.load()), i.load() * pt.Int(2))])),
+            pt.Approve(),
         ]
     )
 
@@ -442,26 +453,38 @@ def test_compile_for():
 int 1
 return
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
     # nested
-    i = ScratchVar()
-    j = ScratchVar()
-    program = Seq(
+    i = pt.ScratchVar()
+    j = pt.ScratchVar()
+    program = pt.Seq(
         [
-            For(i.store(Int(0)), i.load() < Int(10), i.store(i.load() + Int(1))).Do(
-                Seq(
+            pt.For(
+                i.store(pt.Int(0)), i.load() < pt.Int(10), i.store(i.load() + pt.Int(1))
+            ).Do(
+                pt.Seq(
                     [
-                        For(
-                            j.store(Int(0)),
-                            j.load() < Int(4),
-                            j.store(j.load() + Int(2)),
-                        ).Do(Seq([App.globalPut(Itob(j.load()), j.load() * Int(2))]))
+                        pt.For(
+                            j.store(pt.Int(0)),
+                            j.load() < pt.Int(4),
+                            j.store(j.load() + pt.Int(2)),
+                        ).Do(
+                            pt.Seq(
+                                [
+                                    pt.App.globalPut(
+                                        pt.Itob(j.load()), j.load() * pt.Int(2)
+                                    )
+                                ]
+                            )
+                        )
                     ]
                 )
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -501,21 +524,28 @@ def test_compile_for():
 int 1
 return
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
 
 def test_compile_break():
 
-    # While
-    i = ScratchVar()
-    program = Seq(
+    # pt.While
+    i = pt.ScratchVar()
+    program = pt.Seq(
         [
-            i.store(Int(0)),
-            While(i.load() < Int(3)).Do(
-                Seq([If(i.load() == Int(2), Break()), i.store(i.load() + Int(1))])
+            i.store(pt.Int(0)),
+            pt.While(i.load() < pt.Int(3)).Do(
+                pt.Seq(
+                    [
+                        pt.If(i.load() == pt.Int(2), pt.Break()),
+                        i.store(i.load() + pt.Int(1)),
+                    ]
+                )
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -540,22 +570,26 @@ def test_compile_break():
 int 1
 return
             """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
-    # For
-    i = ScratchVar()
-    program = Seq(
+    # pt.For
+    i = pt.ScratchVar()
+    program = pt.Seq(
         [
-            For(i.store(Int(0)), i.load() < Int(10), i.store(i.load() + Int(1))).Do(
-                Seq(
+            pt.For(
+                i.store(pt.Int(0)), i.load() < pt.Int(10), i.store(i.load() + pt.Int(1))
+            ).Do(
+                pt.Seq(
                     [
-                        If(i.load() == Int(4), Break()),
-                        App.globalPut(Itob(i.load()), i.load() * Int(2)),
+                        pt.If(i.load() == pt.Int(4), pt.Break()),
+                        pt.App.globalPut(pt.Itob(i.load()), i.load() * pt.Int(2)),
                     ]
                 )
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -586,20 +620,27 @@ def test_compile_break():
 int 1
 return
         """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
 
 def test_compile_continue():
-    # While
-    i = ScratchVar()
-    program = Seq(
+    # pt.While
+    i = pt.ScratchVar()
+    program = pt.Seq(
         [
-            i.store(Int(0)),
-            While(i.load() < Int(3)).Do(
-                Seq([If(i.load() == Int(2), Continue()), i.store(i.load() + Int(1))])
+            i.store(pt.Int(0)),
+            pt.While(i.load() < pt.Int(3)).Do(
+                pt.Seq(
+                    [
+                        pt.If(i.load() == pt.Int(2), pt.Continue()),
+                        i.store(i.load() + pt.Int(1)),
+                    ]
+                )
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -625,22 +666,26 @@ def test_compile_continue():
 int 1
 return
                 """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
-    # For
-    i = ScratchVar()
-    program = Seq(
+    # pt.For
+    i = pt.ScratchVar()
+    program = pt.Seq(
         [
-            For(i.store(Int(0)), i.load() < Int(10), i.store(i.load() + Int(1))).Do(
-                Seq(
+            pt.For(
+                i.store(pt.Int(0)), i.load() < pt.Int(10), i.store(i.load() + pt.Int(1))
+            ).Do(
+                pt.Seq(
                     [
-                        If(i.load() == Int(4), Continue()),
-                        App.globalPut(Itob(i.load()), i.load() * Int(2)),
+                        pt.If(i.load() == pt.Int(4), pt.Continue()),
+                        pt.App.globalPut(pt.Itob(i.load()), i.load() * pt.Int(2)),
                     ]
                 )
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -672,25 +717,27 @@ def test_compile_continue():
 int 1
 return
             """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
 
 def test_compile_continue_break_nested():
 
-    i = ScratchVar()
-    program = Seq(
+    i = pt.ScratchVar()
+    program = pt.Seq(
         [
-            i.store(Int(0)),
-            While(i.load() < Int(10)).Do(
-                Seq(
+            i.store(pt.Int(0)),
+            pt.While(i.load() < pt.Int(10)).Do(
+                pt.Seq(
                     [
-                        i.store(i.load() + Int(1)),
-                        If(i.load() < Int(4), Continue(), Break()),
+                        i.store(i.load() + pt.Int(1)),
+                        pt.If(i.load() < pt.Int(4), pt.Continue(), pt.Break()),
                     ]
                 )
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -714,31 +761,33 @@ def test_compile_continue_break_nested():
 int 1
 return
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
-    i = ScratchVar()
-    program = Seq(
+    i = pt.ScratchVar()
+    program = pt.Seq(
         [
-            i.store(Int(0)),
-            While(i.load() < Int(10)).Do(
-                Seq(
+            i.store(pt.Int(0)),
+            pt.While(i.load() < pt.Int(10)).Do(
+                pt.Seq(
                     [
-                        If(i.load() == Int(8), Break()),
-                        While(i.load() < Int(6)).Do(
-                            Seq(
+                        pt.If(i.load() == pt.Int(8), pt.Break()),
+                        pt.While(i.load() < pt.Int(6)).Do(
+                            pt.Seq(
                                 [
-                                    If(i.load() == Int(3), Break()),
-                                    i.store(i.load() + Int(1)),
+                                    pt.If(i.load() == pt.Int(3), pt.Break()),
+                                    i.store(i.load() + pt.Int(1)),
                                 ]
                             )
                         ),
-                        If(i.load() < Int(5), Continue()),
-                        i.store(i.load() + Int(1)),
+                        pt.If(i.load() < pt.Int(5), pt.Continue()),
+                        i.store(i.load() + pt.Int(1)),
                     ]
                 )
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -784,39 +833,41 @@ def test_compile_continue_break_nested():
 int 1
 return
 """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert expected == actual
 
 
 def test_compile_subroutine_unsupported():
-    @Subroutine(TealType.none)
-    def storeValue(value: Expr) -> Expr:
-        return App.globalPut(Bytes("key"), value)
+    @pt.Subroutine(pt.TealType.none)
+    def storeValue(value: pt.Expr) -> pt.Expr:
+        return pt.App.globalPut(pt.Bytes("key"), value)
 
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.sender() == Global.creator_address()).Then(
-                storeValue(Txn.application_args[0])
+            pt.If(pt.Txn.sender() == pt.Global.creator_address()).Then(
+                storeValue(pt.Txn.application_args[0])
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
-    with pytest.raises(TealInputError):
-        compileTeal(program, Mode.Application, version=3)
+    with pytest.raises(pt.TealInputError):
+        pt.compileTeal(program, pt.Mode.Application, version=3)
 
 
 def test_compile_subroutine_no_return():
-    @Subroutine(TealType.none)
-    def storeValue(value: Expr) -> Expr:
-        return App.globalPut(Bytes("key"), value)
+    @pt.Subroutine(pt.TealType.none)
+    def storeValue(value: pt.Expr) -> pt.Expr:
+        return pt.App.globalPut(pt.Bytes("key"), value)
 
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.sender() == Global.creator_address()).Then(
-                storeValue(Txn.application_args[0])
+            pt.If(pt.Txn.sender() == pt.Global.creator_address()).Then(
+                storeValue(pt.Txn.application_args[0])
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -839,26 +890,28 @@ def storeValue(value: Expr) -> Expr:
 app_global_put
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_with_return():
-    @Subroutine(TealType.none)
-    def storeValue(value: Expr) -> Expr:
-        return App.globalPut(Bytes("key"), value)
+    @pt.Subroutine(pt.TealType.none)
+    def storeValue(value: pt.Expr) -> pt.Expr:
+        return pt.App.globalPut(pt.Bytes("key"), value)
 
-    @Subroutine(TealType.bytes)
-    def getValue() -> Expr:
-        return App.globalGet(Bytes("key"))
+    @pt.Subroutine(pt.TealType.bytes)
+    def getValue() -> pt.Expr:
+        return pt.App.globalGet(pt.Bytes("key"))
 
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.sender() == Global.creator_address()).Then(
-                storeValue(Txn.application_args[0])
+            pt.If(pt.Txn.sender() == pt.Global.creator_address()).Then(
+                storeValue(pt.Txn.application_args[0])
             ),
-            If(getValue() == Bytes("fail")).Then(Reject()),
-            Approve(),
+            pt.If(getValue() == pt.Bytes("fail")).Then(pt.Reject()),
+            pt.Approve(),
         ]
     )
 
@@ -896,20 +949,22 @@ def getValue() -> Expr:
 app_global_get
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_many_args():
-    @Subroutine(TealType.uint64)
+    @pt.Subroutine(pt.TealType.uint64)
     def calculateSum(
-        a1: Expr, a2: Expr, a3: Expr, a4: Expr, a5: Expr, a6: Expr
-    ) -> Expr:
+        a1: pt.Expr, a2: pt.Expr, a3: pt.Expr, a4: pt.Expr, a5: pt.Expr, a6: pt.Expr
+    ) -> pt.Expr:
         return a1 + a2 + a3 + a4 + a5 + a6
 
-    program = Return(
-        calculateSum(Int(1), Int(2), Int(3), Int(4), Int(5), Int(6))
-        == Int(1 + 2 + 3 + 4 + 5 + 6)
+    program = pt.Return(
+        calculateSum(pt.Int(1), pt.Int(2), pt.Int(3), pt.Int(4), pt.Int(5), pt.Int(6))
+        == pt.Int(1 + 2 + 3 + 4 + 5 + 6)
     )
 
     expected = """#pragma version 4
@@ -945,22 +1000,24 @@ def calculateSum(
 +
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_recursive():
-    @Subroutine(TealType.uint64)
-    def isEven(i: Expr) -> Expr:
+    @pt.Subroutine(pt.TealType.uint64)
+    def isEven(i: pt.Expr) -> pt.Expr:
         return (
-            If(i == Int(0))
-            .Then(Int(1))
-            .ElseIf(i == Int(1))
-            .Then(Int(0))
-            .Else(isEven(i - Int(2)))
+            pt.If(i == pt.Int(0))
+            .Then(pt.Int(1))
+            .ElseIf(i == pt.Int(1))
+            .Then(pt.Int(0))
+            .Else(isEven(i - pt.Int(2)))
         )
 
-    program = Return(isEven(Int(6)))
+    program = pt.Return(isEven(pt.Int(6)))
 
     expected = """#pragma version 4
 int 6
@@ -997,22 +1054,24 @@ def isEven(i: Expr) -> Expr:
 isEven_0_l5:
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_recursive_5():
-    @Subroutine(TealType.uint64)
-    def isEven(i: Expr) -> Expr:
+    @pt.Subroutine(pt.TealType.uint64)
+    def isEven(i: pt.Expr) -> pt.Expr:
         return (
-            If(i == Int(0))
-            .Then(Int(1))
-            .ElseIf(i == Int(1))
-            .Then(Int(0))
-            .Else(isEven(i - Int(2)))
+            pt.If(i == pt.Int(0))
+            .Then(pt.Int(1))
+            .ElseIf(i == pt.Int(1))
+            .Then(pt.Int(0))
+            .Else(isEven(i - pt.Int(2)))
         )
 
-    program = Return(isEven(Int(6)))
+    program = pt.Return(isEven(pt.Int(6)))
 
     expected = """#pragma version 5
 int 6
@@ -1047,20 +1106,22 @@ def isEven(i: Expr) -> Expr:
 isEven_0_l5:
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=5, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=5, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_recursive_multiple_args():
-    @Subroutine(TealType.uint64)
+    @pt.Subroutine(pt.TealType.uint64)
     def multiplyByAdding(a, b):
         return (
-            If(a == Int(0))
-            .Then(Return(Int(0)))
-            .Else(Return(b + multiplyByAdding(a - Int(1), b)))
+            pt.If(a == pt.Int(0))
+            .Then(pt.Return(pt.Int(0)))
+            .Else(pt.Return(b + multiplyByAdding(a - pt.Int(1), b)))
         )
 
-    program = Return(multiplyByAdding(Int(3), Int(5)))
+    program = pt.Return(multiplyByAdding(pt.Int(3), pt.Int(5)))
 
     expected = """#pragma version 4
 int 3
@@ -1101,20 +1162,22 @@ def multiplyByAdding(a, b):
 int 0
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_recursive_multiple_args_5():
-    @Subroutine(TealType.uint64)
+    @pt.Subroutine(pt.TealType.uint64)
     def multiplyByAdding(a, b):
         return (
-            If(a == Int(0))
-            .Then(Return(Int(0)))
-            .Else(Return(b + multiplyByAdding(a - Int(1), b)))
+            pt.If(a == pt.Int(0))
+            .Then(pt.Return(pt.Int(0)))
+            .Else(pt.Return(b + multiplyByAdding(a - pt.Int(1), b)))
         )
 
-    program = Return(multiplyByAdding(Int(3), Int(5)))
+    program = pt.Return(multiplyByAdding(pt.Int(3), pt.Int(5)))
 
     expected = """#pragma version 5
 int 3
@@ -1149,20 +1212,22 @@ def multiplyByAdding(a, b):
 int 0
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=5, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=5, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_mutually_recursive_4():
-    @Subroutine(TealType.uint64)
-    def isEven(i: Expr) -> Expr:
-        return If(i == Int(0), Int(1), Not(isOdd(i - Int(1))))
+    @pt.Subroutine(pt.TealType.uint64)
+    def isEven(i: pt.Expr) -> pt.Expr:
+        return pt.If(i == pt.Int(0), pt.Int(1), pt.Not(isOdd(i - pt.Int(1))))
 
-    @Subroutine(TealType.uint64)
-    def isOdd(i: Expr) -> Expr:
-        return If(i == Int(0), Int(0), Not(isEven(i - Int(1))))
+    @pt.Subroutine(pt.TealType.uint64)
+    def isOdd(i: pt.Expr) -> pt.Expr:
+        return pt.If(i == pt.Int(0), pt.Int(0), pt.Not(isEven(i - pt.Int(1))))
 
-    program = Return(isEven(Int(6)))
+    program = pt.Return(isEven(pt.Int(6)))
 
     expected = """#pragma version 4
 int 6
@@ -1217,20 +1282,22 @@ def isOdd(i: Expr) -> Expr:
 isOdd_1_l3:
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_mutually_recursive_5():
-    @Subroutine(TealType.uint64)
-    def isEven(i: Expr) -> Expr:
-        return If(i == Int(0), Int(1), Not(isOdd(i - Int(1))))
+    @pt.Subroutine(pt.TealType.uint64)
+    def isEven(i: pt.Expr) -> pt.Expr:
+        return pt.If(i == pt.Int(0), pt.Int(1), pt.Not(isOdd(i - pt.Int(1))))
 
-    @Subroutine(TealType.uint64)
-    def isOdd(i: Expr) -> Expr:
-        return If(i == Int(0), Int(0), Not(isEven(i - Int(1))))
+    @pt.Subroutine(pt.TealType.uint64)
+    def isOdd(i: pt.Expr) -> pt.Expr:
+        return pt.If(i == pt.Int(0), pt.Int(0), pt.Not(isEven(i - pt.Int(1))))
 
-    program = Return(isEven(Int(6)))
+    program = pt.Return(isEven(pt.Int(6)))
 
     expected = """#pragma version 5
 int 6
@@ -1281,24 +1348,26 @@ def isOdd(i: Expr) -> Expr:
 isOdd_1_l3:
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=5, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=5, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_mutually_recursive_different_arg_count_4():
-    @Subroutine(TealType.uint64)
-    def factorial(i: Expr) -> Expr:
-        return If(
-            i <= Int(1),
-            Int(1),
-            factorial_intermediate(i - Int(1), Bytes("inconsequential")) * i,
+    @pt.Subroutine(pt.TealType.uint64)
+    def factorial(i: pt.Expr) -> pt.Expr:
+        return pt.If(
+            i <= pt.Int(1),
+            pt.Int(1),
+            factorial_intermediate(i - pt.Int(1), pt.Bytes("inconsequential")) * i,
         )
 
-    @Subroutine(TealType.uint64)
-    def factorial_intermediate(i: Expr, j: Expr) -> Expr:
-        return Seq(Pop(j), factorial(i))
+    @pt.Subroutine(pt.TealType.uint64)
+    def factorial_intermediate(i: pt.Expr, j: pt.Expr) -> pt.Expr:
+        return pt.Seq(pt.Pop(j), factorial(i))
 
-    program = Return(factorial(Int(4)) == Int(24))
+    program = pt.Return(factorial(pt.Int(4)) == pt.Int(24))
 
     expected = """#pragma version 4
 int 4
@@ -1356,24 +1425,26 @@ def factorial_intermediate(i: Expr, j: Expr) -> Expr:
 pop
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_mutually_recursive_different_arg_count_5():
-    @Subroutine(TealType.uint64)
-    def factorial(i: Expr) -> Expr:
-        return If(
-            i <= Int(1),
-            Int(1),
-            factorial_intermediate(i - Int(1), Bytes("inconsequential")) * i,
+    @pt.Subroutine(pt.TealType.uint64)
+    def factorial(i: pt.Expr) -> pt.Expr:
+        return pt.If(
+            i <= pt.Int(1),
+            pt.Int(1),
+            factorial_intermediate(i - pt.Int(1), pt.Bytes("inconsequential")) * i,
         )
 
-    @Subroutine(TealType.uint64)
-    def factorial_intermediate(i: Expr, j: Expr) -> Expr:
-        return Seq(Log(j), factorial(i))
+    @pt.Subroutine(pt.TealType.uint64)
+    def factorial_intermediate(i: pt.Expr, j: pt.Expr) -> pt.Expr:
+        return pt.Seq(pt.Log(j), factorial(i))
 
-    program = Return(factorial(Int(4)) == Int(24))
+    program = pt.Return(factorial(pt.Int(4)) == pt.Int(24))
 
     expected = """#pragma version 5
 int 4
@@ -1422,19 +1493,21 @@ def factorial_intermediate(i: Expr, j: Expr) -> Expr:
 store 1
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=5, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=5, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_loop_in_subroutine():
-    @Subroutine(TealType.none)
-    def setState(value: Expr) -> Expr:
-        i = ScratchVar()
-        return For(i.store(Int(0)), i.load() < Int(10), i.store(i.load() + Int(1))).Do(
-            App.globalPut(Itob(i.load()), value)
-        )
+    @pt.Subroutine(pt.TealType.none)
+    def setState(value: pt.Expr) -> pt.Expr:
+        i = pt.ScratchVar()
+        return pt.For(
+            i.store(pt.Int(0)), i.load() < pt.Int(10), i.store(i.load() + pt.Int(1))
+        ).Do(pt.App.globalPut(pt.Itob(i.load()), value))
 
-    program = Seq([setState(Bytes("value")), Approve()])
+    program = pt.Seq([setState(pt.Bytes("value")), pt.Approve()])
 
     expected = """#pragma version 4
 byte "value"
@@ -1464,17 +1537,19 @@ def setState(value: Expr) -> Expr:
 setState_0_l3:
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_invalid_name():
-    def tmp() -> Expr:
-        return Int(1)
+    def tmp() -> pt.Expr:
+        return pt.Int(1)
 
     tmp.__name__ = "invalid-;)"
 
-    program = Subroutine(TealType.uint64)(tmp)()
+    program = pt.Subroutine(pt.TealType.uint64)(tmp)()
     expected = """#pragma version 4
 callsub invalid_0
 return
@@ -1484,26 +1559,28 @@ def tmp() -> Expr:
 int 1
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=False)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=False
+    )
     assert actual == expected
 
 
 def test_compile_subroutine_assemble_constants():
-    @Subroutine(TealType.none)
-    def storeValue(key: Expr, t1: Expr, t2: Expr, t3: Expr) -> Expr:
-        return App.globalPut(key, t1 + t2 + t3 + Int(10))
+    @pt.Subroutine(pt.TealType.none)
+    def storeValue(key: pt.Expr, t1: pt.Expr, t2: pt.Expr, t3: pt.Expr) -> pt.Expr:
+        return pt.App.globalPut(key, t1 + t2 + t3 + pt.Int(10))
 
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.application_id() == Int(0)).Then(
+            pt.If(pt.Txn.application_id() == pt.Int(0)).Then(
                 storeValue(
-                    Concat(Bytes("test"), Bytes("test"), Bytes("a")),
-                    Int(1),
-                    Int(1),
-                    Int(3),
+                    pt.Concat(pt.Bytes("test"), pt.Bytes("test"), pt.Bytes("a")),
+                    pt.Int(1),
+                    pt.Int(1),
+                    pt.Int(3),
                 )
             ),
-            Approve(),
+            pt.Approve(),
         ]
     )
 
@@ -1544,14 +1621,16 @@ def storeValue(key: Expr, t1: Expr, t2: Expr, t3: Expr) -> Expr:
 app_global_put
 retsub
     """.strip()
-    actual = compileTeal(program, Mode.Application, version=4, assembleConstants=True)
+    actual = pt.compileTeal(
+        program, pt.Mode.Application, version=4, assembleConstants=True
+    )
     assert actual == expected
 
 
 def test_compile_wide_ratio():
     cases = (
         (
-            WideRatio([Int(2), Int(100)], [Int(5)]),
+            pt.WideRatio([pt.Int(2), pt.Int(100)], [pt.Int(5)]),
             """#pragma version 5
 int 2
 int 100
@@ -1568,7 +1647,7 @@ def test_compile_wide_ratio():
 """,
         ),
         (
-            WideRatio([Int(2), Int(100)], [Int(10), Int(5)]),
+            pt.WideRatio([pt.Int(2), pt.Int(100)], [pt.Int(10), pt.Int(5)]),
             """#pragma version 5
 int 2
 int 100
@@ -1586,7 +1665,7 @@ def test_compile_wide_ratio():
 """,
         ),
         (
-            WideRatio([Int(2), Int(100), Int(3)], [Int(10), Int(5)]),
+            pt.WideRatio([pt.Int(2), pt.Int(100), pt.Int(3)], [pt.Int(10), pt.Int(5)]),
             """#pragma version 5
 int 2
 int 100
@@ -1613,7 +1692,9 @@ def test_compile_wide_ratio():
 """,
         ),
         (
-            WideRatio([Int(2), Int(100), Int(3)], [Int(10), Int(5), Int(6)]),
+            pt.WideRatio(
+                [pt.Int(2), pt.Int(100), pt.Int(3)], [pt.Int(10), pt.Int(5), pt.Int(6)]
+            ),
             """#pragma version 5
 int 2
 int 100
@@ -1649,7 +1730,10 @@ def test_compile_wide_ratio():
 """,
         ),
         (
-            WideRatio([Int(2), Int(100), Int(3), Int(4)], [Int(10), Int(5), Int(6)]),
+            pt.WideRatio(
+                [pt.Int(2), pt.Int(100), pt.Int(3), pt.Int(4)],
+                [pt.Int(10), pt.Int(5), pt.Int(6)],
+            ),
             """#pragma version 5
 int 2
 int 100
@@ -1696,7 +1780,7 @@ def test_compile_wide_ratio():
     )
 
     for program, expected in cases:
-        actual = compileTeal(
-            program, Mode.Application, version=5, assembleConstants=False
+        actual = pt.compileTeal(
+            program, pt.Mode.Application, version=5, assembleConstants=False
         )
         assert actual == expected.strip()
diff --git a/pyteal/compiler/constants_test.py b/pyteal/compiler/constants_test.py
index d9c3a2b4b..d835c4c1e 100644
--- a/pyteal/compiler/constants_test.py
+++ b/pyteal/compiler/constants_test.py
@@ -1,4 +1,4 @@
-from .. import *
+import pyteal as pt
 
 from .constants import (
     extractIntValue,
@@ -11,12 +11,12 @@
 
 def test_extractIntValue():
     tests = [
-        (TealOp(None, Op.int, 0), 0),
-        (TealOp(None, Op.int, 5), 5),
-        (TealOp(None, Op.int, "pay"), 1),
-        (TealOp(None, Op.int, "NoOp"), 0),
-        (TealOp(None, Op.int, "UpdateApplication"), 4),
-        (TealOp(None, Op.int, "TMPL_NAME"), "TMPL_NAME"),
+        (pt.TealOp(None, pt.Op.int, 0), 0),
+        (pt.TealOp(None, pt.Op.int, 5), 5),
+        (pt.TealOp(None, pt.Op.int, "pay"), 1),
+        (pt.TealOp(None, pt.Op.int, "NoOp"), 0),
+        (pt.TealOp(None, pt.Op.int, "UpdateApplication"), 4),
+        (pt.TealOp(None, pt.Op.int, "TMPL_NAME"), "TMPL_NAME"),
     ]
 
     for op, expected in tests:
@@ -26,19 +26,19 @@ def test_extractIntValue():
 
 def test_extractBytesValue():
     tests = [
-        (TealOp(None, Op.byte, '""'), b""),
-        (TealOp(None, Op.byte, '"test"'), b"test"),
-        (TealOp(None, Op.byte, '"\\t\\n\\\\\\""'), b'\t\n\\"'),
-        (TealOp(None, Op.byte, "0x"), b""),
-        (TealOp(None, Op.byte, "0x00"), b"\x00"),
-        (TealOp(None, Op.byte, "0xFF00"), b"\xff\x00"),
-        (TealOp(None, Op.byte, "0xff00"), b"\xff\x00"),
-        (TealOp(None, Op.byte, "base32()"), b""),
-        (TealOp(None, Op.byte, "base32(ORSXG5A)"), b"test"),
-        (TealOp(None, Op.byte, "base32(ORSXG5A=)"), b"test"),
-        (TealOp(None, Op.byte, "base64()"), b""),
-        (TealOp(None, Op.byte, "base64(dGVzdA==)"), b"test"),
-        (TealOp(None, Op.byte, "TMPL_NAME"), "TMPL_NAME"),
+        (pt.TealOp(None, pt.Op.byte, '""'), b""),
+        (pt.TealOp(None, pt.Op.byte, '"test"'), b"test"),
+        (pt.TealOp(None, pt.Op.byte, '"\\t\\n\\\\\\""'), b'\t\n\\"'),
+        (pt.TealOp(None, pt.Op.byte, "0x"), b""),
+        (pt.TealOp(None, pt.Op.byte, "0x00"), b"\x00"),
+        (pt.TealOp(None, pt.Op.byte, "0xFF00"), b"\xff\x00"),
+        (pt.TealOp(None, pt.Op.byte, "0xff00"), b"\xff\x00"),
+        (pt.TealOp(None, pt.Op.byte, "base32()"), b""),
+        (pt.TealOp(None, pt.Op.byte, "base32(ORSXG5A)"), b"test"),
+        (pt.TealOp(None, pt.Op.byte, "base32(ORSXG5A=)"), b"test"),
+        (pt.TealOp(None, pt.Op.byte, "base64()"), b""),
+        (pt.TealOp(None, pt.Op.byte, "base64(dGVzdA==)"), b"test"),
+        (pt.TealOp(None, pt.Op.byte, "TMPL_NAME"), "TMPL_NAME"),
     ]
 
     for op, expected in tests:
@@ -49,14 +49,14 @@ def test_extractBytesValue():
 def test_extractAddrValue():
     tests = [
         (
-            TealOp(
+            pt.TealOp(
                 None,
-                Op.byte,
+                pt.Op.byte,
                 "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M",
             ),
             b"\xb4\x92v\xbd>\xc0\x97~\xab\x86\xa3!\xc4I\xea\xd8\x02\xc9l\x0b\xd9|)V\x13\x15\x11\xd2\xf1\x1e\xeb\xec",
         ),
-        (TealOp(None, Op.addr, "TMPL_NAME"), "TMPL_NAME"),
+        (pt.TealOp(None, pt.Op.addr, "TMPL_NAME"), "TMPL_NAME"),
     ]
 
     for op, expected in tests:
@@ -68,29 +68,38 @@ def test_extractAddrValue():
 def test_extractMethodValue():
     tests = [
         (
-            TealOp(None, Op.method_signature, '"create(uint64)uint64"'),
+            pt.TealOp(None, pt.Op.method_signature, '"create(uint64)uint64"'),
             b"\x43\x46\x41\x01",
         ),
-        (TealOp(None, Op.method_signature, '"update()void"'), b"\xa0\xe8\x18\x72"),
         (
-            TealOp(None, Op.method_signature, '"optIn(string)string"'),
+            pt.TealOp(None, pt.Op.method_signature, '"update()void"'),
+            b"\xa0\xe8\x18\x72",
+        ),
+        (
+            pt.TealOp(None, pt.Op.method_signature, '"optIn(string)string"'),
             b"\xcf\xa6\x8e\x36",
         ),
-        (TealOp(None, Op.method_signature, '"closeOut()string"'), b"\xa9\xf4\x2b\x3d"),
-        (TealOp(None, Op.method_signature, '"delete()void"'), b"\x24\x37\x8d\x3c"),
         (
-            TealOp(None, Op.method_signature, '"add(uint64,uint64)uint64"'),
+            pt.TealOp(None, pt.Op.method_signature, '"closeOut()string"'),
+            b"\xa9\xf4\x2b\x3d",
+        ),
+        (
+            pt.TealOp(None, pt.Op.method_signature, '"delete()void"'),
+            b"\x24\x37\x8d\x3c",
+        ),
+        (
+            pt.TealOp(None, pt.Op.method_signature, '"add(uint64,uint64)uint64"'),
             b"\xfe\x6b\xdf\x69",
         ),
-        (TealOp(None, Op.method_signature, '"empty()void"'), b"\xa8\x8c\x26\xa5"),
+        (pt.TealOp(None, pt.Op.method_signature, '"empty()void"'), b"\xa8\x8c\x26\xa5"),
         (
-            TealOp(None, Op.method_signature, '"payment(pay,uint64)bool"'),
+            pt.TealOp(None, pt.Op.method_signature, '"payment(pay,uint64)bool"'),
             b"\x3e\x3b\x3d\x28",
         ),
         (
-            TealOp(
+            pt.TealOp(
                 None,
-                Op.method_signature,
+                pt.Op.method_signature,
                 '"referenceTest(account,application,account,asset,account,asset,asset,application,application)uint8[9]"',
             ),
             b"\x0d\xf0\x05\x0f",
@@ -113,9 +122,9 @@ def test_createConstantBlocks_empty():
 
 def test_createConstantBlocks_no_consts():
     ops = [
-        TealOp(None, Op.txn, "Sender"),
-        TealOp(None, Op.txn, "Receiver"),
-        TealOp(None, Op.eq),
+        pt.TealOp(None, pt.Op.txn, "Sender"),
+        pt.TealOp(None, pt.Op.txn, "Receiver"),
+        pt.TealOp(None, pt.Op.eq),
     ]
 
     expected = ops[:]
@@ -126,15 +135,15 @@ def test_createConstantBlocks_no_consts():
 
 def test_createConstantBlocks_pushint():
     ops = [
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.int, "OptIn"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.int, "OptIn"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     expected = [
-        TealOp(None, Op.pushint, 0, "//", 0),
-        TealOp(None, Op.pushint, 1, "//", "OptIn"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.pushint, 0, "//", 0),
+        pt.TealOp(None, pt.Op.pushint, 1, "//", "OptIn"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     actual = createConstantBlocks(ops)
@@ -143,16 +152,16 @@ def test_createConstantBlocks_pushint():
 
 def test_createConstantBlocks_intblock_single():
     ops = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, "OptIn"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, "OptIn"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     expected = [
-        TealOp(None, Op.intcblock, 1),
-        TealOp(None, Op.intc_0, "//", 1),
-        TealOp(None, Op.intc_0, "//", "OptIn"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.intcblock, 1),
+        pt.TealOp(None, pt.Op.intc_0, "//", 1),
+        pt.TealOp(None, pt.Op.intc_0, "//", "OptIn"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     actual = createConstantBlocks(ops)
@@ -161,28 +170,28 @@ def test_createConstantBlocks_intblock_single():
 
 def test_createConstantBlocks_intblock_multiple():
     ops = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, "OptIn"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, "keyreg"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.int, "ClearState"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, "OptIn"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, "keyreg"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.int, "ClearState"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     expected = [
-        TealOp(None, Op.intcblock, 1, 2, 3),
-        TealOp(None, Op.intc_0, "//", 1),
-        TealOp(None, Op.intc_0, "//", "OptIn"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.intc_1, "//", 2),
-        TealOp(None, Op.intc_1, "//", "keyreg"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.intc_2, "//", 3),
-        TealOp(None, Op.intc_2, "//", "ClearState"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.intcblock, 1, 2, 3),
+        pt.TealOp(None, pt.Op.intc_0, "//", 1),
+        pt.TealOp(None, pt.Op.intc_0, "//", "OptIn"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.intc_1, "//", 2),
+        pt.TealOp(None, pt.Op.intc_1, "//", "keyreg"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.intc_2, "//", 3),
+        pt.TealOp(None, pt.Op.intc_2, "//", "ClearState"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     actual = createConstantBlocks(ops)
@@ -191,28 +200,28 @@ def test_createConstantBlocks_intblock_multiple():
 
 def test_createConstantBlocks_intblock_pushint():
     ops = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, "OptIn"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.int, "ClearState"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, "OptIn"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.int, "ClearState"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     expected = [
-        TealOp(None, Op.intcblock, 3, 1),
-        TealOp(None, Op.intc_1, "//", 1),
-        TealOp(None, Op.intc_1, "//", "OptIn"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.pushint, 2, "//", 2),
-        TealOp(None, Op.intc_0, "//", 3),
-        TealOp(None, Op.add),
-        TealOp(None, Op.intc_0, "//", 3),
-        TealOp(None, Op.intc_0, "//", "ClearState"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.intcblock, 3, 1),
+        pt.TealOp(None, pt.Op.intc_1, "//", 1),
+        pt.TealOp(None, pt.Op.intc_1, "//", "OptIn"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.pushint, 2, "//", 2),
+        pt.TealOp(None, pt.Op.intc_0, "//", 3),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.intc_0, "//", 3),
+        pt.TealOp(None, pt.Op.intc_0, "//", "ClearState"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     actual = createConstantBlocks(ops)
@@ -221,17 +230,17 @@ def test_createConstantBlocks_intblock_pushint():
 
 def test_createConstantBlocks_pushbytes():
     ops = [
-        TealOp(None, Op.byte, "0x0102"),
-        TealOp(None, Op.byte, "0x0103"),
-        TealOp(None, Op.method_signature, '"empty()void"'),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.byte, "0x0102"),
+        pt.TealOp(None, pt.Op.byte, "0x0103"),
+        pt.TealOp(None, pt.Op.method_signature, '"empty()void"'),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     expected = [
-        TealOp(None, Op.pushbytes, "0x0102", "//", "0x0102"),
-        TealOp(None, Op.pushbytes, "0x0103", "//", "0x0103"),
-        TealOp(None, Op.pushbytes, "0xa88c26a5", "//", '"empty()void"'),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.pushbytes, "0x0102", "//", "0x0102"),
+        pt.TealOp(None, pt.Op.pushbytes, "0x0103", "//", "0x0103"),
+        pt.TealOp(None, pt.Op.pushbytes, "0xa88c26a5", "//", '"empty()void"'),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     actual = createConstantBlocks(ops)
@@ -240,20 +249,20 @@ def test_createConstantBlocks_pushbytes():
 
 def test_createConstantBlocks_byteblock_single():
     ops = [
-        TealOp(None, Op.byte, "0x0102"),
-        TealOp(None, Op.byte, "base64(AQI=)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "base32(AEBA====)"),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.byte, "0x0102"),
+        pt.TealOp(None, pt.Op.byte, "base64(AQI=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "base32(AEBA====)"),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     expected = [
-        TealOp(None, Op.bytecblock, "0x0102"),
-        TealOp(None, Op.bytec_0, "//", "0x0102"),
-        TealOp(None, Op.bytec_0, "//", "base64(AQI=)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_0, "//", "base32(AEBA====)"),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.bytecblock, "0x0102"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "0x0102"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "base64(AQI=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "base32(AEBA====)"),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     actual = createConstantBlocks(ops)
@@ -262,65 +271,67 @@ def test_createConstantBlocks_byteblock_single():
 
 def test_createConstantBlocks_byteblock_multiple():
     ops = [
-        TealOp(None, Op.byte, "0x0102"),
-        TealOp(None, Op.byte, "base64(AQI=)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "base32(AEBA====)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, '"test"'),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "base32(ORSXG5A=)"),
-        TealOp(None, Op.concat),
-        TealOp(
+        pt.TealOp(None, pt.Op.byte, "0x0102"),
+        pt.TealOp(None, pt.Op.byte, "base64(AQI=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "base32(AEBA====)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, '"test"'),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "base32(ORSXG5A=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(
             None,
-            Op.byte,
+            pt.Op.byte,
             "0xb49276bd3ec0977eab86a321c449ead802c96c0bd97c2956131511d2f11eebec",
         ),
-        TealOp(None, Op.concat),
-        TealOp(
-            None, Op.addr, "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M"
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(
+            None,
+            pt.Op.addr,
+            "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M",
         ),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.method_signature, '"closeOut()string"'),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "base64(qfQrPQ==)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.method_signature, '"closeOut()string"'),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "base64(qfQrPQ==)"),
     ]
 
     expected = [
-        TealOp(
+        pt.TealOp(
             None,
-            Op.bytecblock,
+            pt.Op.bytecblock,
             "0x0102",
             "0x74657374",
             "0xb49276bd3ec0977eab86a321c449ead802c96c0bd97c2956131511d2f11eebec",
             "0xa9f42b3d",
         ),
-        TealOp(None, Op.bytec_0, "//", "0x0102"),
-        TealOp(None, Op.bytec_0, "//", "base64(AQI=)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_0, "//", "base32(AEBA====)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_1, "//", '"test"'),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_1, "//", "base32(ORSXG5A=)"),
-        TealOp(None, Op.concat),
-        TealOp(
+        pt.TealOp(None, pt.Op.bytec_0, "//", "0x0102"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "base64(AQI=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "base32(AEBA====)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_1, "//", '"test"'),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_1, "//", "base32(ORSXG5A=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(
             None,
-            Op.bytec_2,
+            pt.Op.bytec_2,
             "//",
             "0xb49276bd3ec0977eab86a321c449ead802c96c0bd97c2956131511d2f11eebec",
         ),
-        TealOp(None, Op.concat),
-        TealOp(
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(
             None,
-            Op.bytec_2,
+            pt.Op.bytec_2,
             "//",
             "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M",
         ),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_3, "//", '"closeOut()string"'),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_3, "//", "base64(qfQrPQ==)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_3, "//", '"closeOut()string"'),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_3, "//", "base64(qfQrPQ==)"),
     ]
 
     actual = createConstantBlocks(ops)
@@ -329,40 +340,42 @@ def test_createConstantBlocks_byteblock_multiple():
 
 def test_createConstantBlocks_byteblock_pushbytes():
     ops = [
-        TealOp(None, Op.byte, "0x0102"),
-        TealOp(None, Op.byte, "base64(AQI=)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "base32(AEBA====)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, '"test"'),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "base32(ORSXG5A=)"),
-        TealOp(None, Op.concat),
-        TealOp(
-            None, Op.addr, "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M"
+        pt.TealOp(None, pt.Op.byte, "0x0102"),
+        pt.TealOp(None, pt.Op.byte, "base64(AQI=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "base32(AEBA====)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, '"test"'),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "base32(ORSXG5A=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(
+            None,
+            pt.Op.addr,
+            "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M",
         ),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     expected = [
-        TealOp(None, Op.bytecblock, "0x0102", "0x74657374"),
-        TealOp(None, Op.bytec_0, "//", "0x0102"),
-        TealOp(None, Op.bytec_0, "//", "base64(AQI=)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_0, "//", "base32(AEBA====)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_1, "//", '"test"'),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_1, "//", "base32(ORSXG5A=)"),
-        TealOp(None, Op.concat),
-        TealOp(
+        pt.TealOp(None, pt.Op.bytecblock, "0x0102", "0x74657374"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "0x0102"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "base64(AQI=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "base32(AEBA====)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_1, "//", '"test"'),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_1, "//", "base32(ORSXG5A=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(
             None,
-            Op.pushbytes,
+            pt.Op.pushbytes,
             "0xb49276bd3ec0977eab86a321c449ead802c96c0bd97c2956131511d2f11eebec",
             "//",
             "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M",
         ),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     actual = createConstantBlocks(ops)
@@ -371,59 +384,61 @@ def test_createConstantBlocks_byteblock_pushbytes():
 
 def test_createConstantBlocks_all():
     ops = [
-        TealOp(None, Op.byte, "0x0102"),
-        TealOp(None, Op.byte, "base64(AQI=)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "base32(AEBA====)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, '"test"'),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "base32(ORSXG5A=)"),
-        TealOp(None, Op.concat),
-        TealOp(
-            None, Op.addr, "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M"
+        pt.TealOp(None, pt.Op.byte, "0x0102"),
+        pt.TealOp(None, pt.Op.byte, "base64(AQI=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "base32(AEBA====)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, '"test"'),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "base32(ORSXG5A=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(
+            None,
+            pt.Op.addr,
+            "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M",
         ),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, "OptIn"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.int, "ClearState"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, "OptIn"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.int, "ClearState"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     expected = [
-        TealOp(None, Op.intcblock, 3, 1),
-        TealOp(None, Op.bytecblock, "0x0102", "0x74657374"),
-        TealOp(None, Op.bytec_0, "//", "0x0102"),
-        TealOp(None, Op.bytec_0, "//", "base64(AQI=)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_0, "//", "base32(AEBA====)"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_1, "//", '"test"'),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_1, "//", "base32(ORSXG5A=)"),
-        TealOp(None, Op.concat),
-        TealOp(
+        pt.TealOp(None, pt.Op.intcblock, 3, 1),
+        pt.TealOp(None, pt.Op.bytecblock, "0x0102", "0x74657374"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "0x0102"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "base64(AQI=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "base32(AEBA====)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_1, "//", '"test"'),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_1, "//", "base32(ORSXG5A=)"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(
             None,
-            Op.pushbytes,
+            pt.Op.pushbytes,
             "0xb49276bd3ec0977eab86a321c449ead802c96c0bd97c2956131511d2f11eebec",
             "//",
             "WSJHNPJ6YCLX5K4GUMQ4ISPK3ABMS3AL3F6CSVQTCUI5F4I65PWEMCWT3M",
         ),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.intc_1, "//", 1),
-        TealOp(None, Op.intc_1, "//", "OptIn"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.pushint, 2, "//", 2),
-        TealOp(None, Op.intc_0, "//", 3),
-        TealOp(None, Op.add),
-        TealOp(None, Op.intc_0, "//", 3),
-        TealOp(None, Op.intc_0, "//", "ClearState"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.intc_1, "//", 1),
+        pt.TealOp(None, pt.Op.intc_1, "//", "OptIn"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.pushint, 2, "//", 2),
+        pt.TealOp(None, pt.Op.intc_0, "//", 3),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.intc_0, "//", 3),
+        pt.TealOp(None, pt.Op.intc_0, "//", "ClearState"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     actual = createConstantBlocks(ops)
@@ -432,20 +447,20 @@ def test_createConstantBlocks_all():
 
 def test_createConstantBlocks_tmpl_int():
     ops = [
-        TealOp(None, Op.int, "TMPL_INT_1"),
-        TealOp(None, Op.int, "TMPL_INT_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.int, "TMPL_INT_2"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.int, "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.int, "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.int, "TMPL_INT_2"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     expected = [
-        TealOp(None, Op.intcblock, "TMPL_INT_1"),
-        TealOp(None, Op.intc_0, "//", "TMPL_INT_1"),
-        TealOp(None, Op.intc_0, "//", "TMPL_INT_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.pushint, "TMPL_INT_2", "//", "TMPL_INT_2"),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.intcblock, "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.intc_0, "//", "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.intc_0, "//", "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.pushint, "TMPL_INT_2", "//", "TMPL_INT_2"),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     actual = createConstantBlocks(ops)
@@ -454,30 +469,30 @@ def test_createConstantBlocks_tmpl_int():
 
 def test_createConstantBlocks_tmpl_int_mixed():
     ops = [
-        TealOp(None, Op.int, "TMPL_INT_1"),
-        TealOp(None, Op.int, "TMPL_INT_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.int, "TMPL_INT_2"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.int, "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.int, "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.int, "TMPL_INT_2"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     expected = [
-        TealOp(None, Op.intcblock, "TMPL_INT_1", 0),
-        TealOp(None, Op.intc_0, "//", "TMPL_INT_1"),
-        TealOp(None, Op.intc_0, "//", "TMPL_INT_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.pushint, "TMPL_INT_2", "//", "TMPL_INT_2"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.intc_1, "//", 0),
-        TealOp(None, Op.intc_1, "//", 0),
-        TealOp(None, Op.add),
-        TealOp(None, Op.pushint, 1, "//", 1),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.intcblock, "TMPL_INT_1", 0),
+        pt.TealOp(None, pt.Op.intc_0, "//", "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.intc_0, "//", "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.pushint, "TMPL_INT_2", "//", "TMPL_INT_2"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.intc_1, "//", 0),
+        pt.TealOp(None, pt.Op.intc_1, "//", 0),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.pushint, 1, "//", 1),
+        pt.TealOp(None, pt.Op.add),
     ]
 
     actual = createConstantBlocks(ops)
@@ -486,20 +501,20 @@ def test_createConstantBlocks_tmpl_int_mixed():
 
 def test_createConstantBlocks_tmpl_bytes():
     ops = [
-        TealOp(None, Op.byte, "TMPL_BYTES_1"),
-        TealOp(None, Op.byte, "TMPL_BYTES_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.byte, "TMPL_BYTES_2"),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.byte, "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.byte, "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.byte, "TMPL_BYTES_2"),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     expected = [
-        TealOp(None, Op.bytecblock, "TMPL_BYTES_1"),
-        TealOp(None, Op.bytec_0, "//", "TMPL_BYTES_1"),
-        TealOp(None, Op.bytec_0, "//", "TMPL_BYTES_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.pushbytes, "TMPL_BYTES_2", "//", "TMPL_BYTES_2"),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.bytecblock, "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.pushbytes, "TMPL_BYTES_2", "//", "TMPL_BYTES_2"),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     actual = createConstantBlocks(ops)
@@ -508,30 +523,30 @@ def test_createConstantBlocks_tmpl_bytes():
 
 def test_createConstantBlocks_tmpl_bytes_mixed():
     ops = [
-        TealOp(None, Op.byte, "TMPL_BYTES_1"),
-        TealOp(None, Op.byte, "TMPL_BYTES_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.byte, "TMPL_BYTES_2"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "0x00"),
-        TealOp(None, Op.byte, "0x00"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "0x01"),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.byte, "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.byte, "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.byte, "TMPL_BYTES_2"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "0x00"),
+        pt.TealOp(None, pt.Op.byte, "0x00"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "0x01"),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     expected = [
-        TealOp(None, Op.bytecblock, "TMPL_BYTES_1", "0x00"),
-        TealOp(None, Op.bytec_0, "//", "TMPL_BYTES_1"),
-        TealOp(None, Op.bytec_0, "//", "TMPL_BYTES_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.pushbytes, "TMPL_BYTES_2", "//", "TMPL_BYTES_2"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_1, "//", "0x00"),
-        TealOp(None, Op.bytec_1, "//", "0x00"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.pushbytes, "0x01", "//", "0x01"),
-        TealOp(None, Op.concat),
+        pt.TealOp(None, pt.Op.bytecblock, "TMPL_BYTES_1", "0x00"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.pushbytes, "TMPL_BYTES_2", "//", "TMPL_BYTES_2"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_1, "//", "0x00"),
+        pt.TealOp(None, pt.Op.bytec_1, "//", "0x00"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.pushbytes, "0x01", "//", "0x01"),
+        pt.TealOp(None, pt.Op.concat),
     ]
 
     actual = createConstantBlocks(ops)
@@ -540,55 +555,55 @@ def test_createConstantBlocks_tmpl_bytes_mixed():
 
 def test_createConstantBlocks_tmpl_all():
     ops = [
-        TealOp(None, Op.byte, "TMPL_BYTES_1"),
-        TealOp(None, Op.byte, "TMPL_BYTES_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.byte, "TMPL_BYTES_2"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "0x00"),
-        TealOp(None, Op.byte, "0x00"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.byte, "0x01"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.len),
-        TealOp(None, Op.int, "TMPL_INT_1"),
-        TealOp(None, Op.int, "TMPL_INT_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.int, "TMPL_INT_2"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.add),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.eq),
+        pt.TealOp(None, pt.Op.byte, "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.byte, "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.byte, "TMPL_BYTES_2"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "0x00"),
+        pt.TealOp(None, pt.Op.byte, "0x00"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.byte, "0x01"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.len),
+        pt.TealOp(None, pt.Op.int, "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.int, "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.int, "TMPL_INT_2"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.eq),
     ]
 
     expected = [
-        TealOp(None, Op.intcblock, "TMPL_INT_1", 0),
-        TealOp(None, Op.bytecblock, "TMPL_BYTES_1", "0x00"),
-        TealOp(None, Op.bytec_0, "//", "TMPL_BYTES_1"),
-        TealOp(None, Op.bytec_0, "//", "TMPL_BYTES_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.pushbytes, "TMPL_BYTES_2", "//", "TMPL_BYTES_2"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.bytec_1, "//", "0x00"),
-        TealOp(None, Op.bytec_1, "//", "0x00"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.pushbytes, "0x01", "//", "0x01"),
-        TealOp(None, Op.concat),
-        TealOp(None, Op.len),
-        TealOp(None, Op.intc_0, "//", "TMPL_INT_1"),
-        TealOp(None, Op.intc_0, "//", "TMPL_INT_1"),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.pushint, "TMPL_INT_2", "//", "TMPL_INT_2"),
-        TealOp(None, Op.add),
-        TealOp(None, Op.intc_1, "//", 0),
-        TealOp(None, Op.intc_1, "//", 0),
-        TealOp(None, Op.add),
-        TealOp(None, Op.pushint, 1, "//", 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.eq),
+        pt.TealOp(None, pt.Op.intcblock, "TMPL_INT_1", 0),
+        pt.TealOp(None, pt.Op.bytecblock, "TMPL_BYTES_1", "0x00"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.bytec_0, "//", "TMPL_BYTES_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.pushbytes, "TMPL_BYTES_2", "//", "TMPL_BYTES_2"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.bytec_1, "//", "0x00"),
+        pt.TealOp(None, pt.Op.bytec_1, "//", "0x00"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.pushbytes, "0x01", "//", "0x01"),
+        pt.TealOp(None, pt.Op.concat),
+        pt.TealOp(None, pt.Op.len),
+        pt.TealOp(None, pt.Op.intc_0, "//", "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.intc_0, "//", "TMPL_INT_1"),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.pushint, "TMPL_INT_2", "//", "TMPL_INT_2"),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.intc_1, "//", 0),
+        pt.TealOp(None, pt.Op.intc_1, "//", 0),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.pushint, 1, "//", 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.eq),
     ]
 
     actual = createConstantBlocks(ops)
@@ -597,35 +612,35 @@ def test_createConstantBlocks_tmpl_all():
 
 def test_createConstantBlocks_intc():
     """Test scenario where there are more than 4 constants in the intcblock.
-    If the 4th constant can't fit in one varuint byte (more than 2**7) it
-    should be referenced with the Op.intc 4 command.
+    pt.If the 4th constant can't fit in one varuint byte (more than 2**7) it
+    should be referenced with the pt.Op.intc 4 command.
     """
 
     ops = [
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.int, 2**7),
-        TealOp(None, Op.int, 2**7),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.int, 2**7),
+        pt.TealOp(None, pt.Op.int, 2**7),
     ]
 
     expected = [
-        TealOp(None, Op.intcblock, 0, 1, 2, 3, 2**7),
-        TealOp(None, Op.intc_0, "//", 0),
-        TealOp(None, Op.intc_0, "//", 0),
-        TealOp(None, Op.intc_1, "//", 1),
-        TealOp(None, Op.intc_1, "//", 1),
-        TealOp(None, Op.intc_2, "//", 2),
-        TealOp(None, Op.intc_2, "//", 2),
-        TealOp(None, Op.intc_3, "//", 3),
-        TealOp(None, Op.intc_3, "//", 3),
-        TealOp(None, Op.intc, 4, "//", 2**7),
-        TealOp(None, Op.intc, 4, "//", 2**7),
+        pt.TealOp(None, pt.Op.intcblock, 0, 1, 2, 3, 2**7),
+        pt.TealOp(None, pt.Op.intc_0, "//", 0),
+        pt.TealOp(None, pt.Op.intc_0, "//", 0),
+        pt.TealOp(None, pt.Op.intc_1, "//", 1),
+        pt.TealOp(None, pt.Op.intc_1, "//", 1),
+        pt.TealOp(None, pt.Op.intc_2, "//", 2),
+        pt.TealOp(None, pt.Op.intc_2, "//", 2),
+        pt.TealOp(None, pt.Op.intc_3, "//", 3),
+        pt.TealOp(None, pt.Op.intc_3, "//", 3),
+        pt.TealOp(None, pt.Op.intc, 4, "//", 2**7),
+        pt.TealOp(None, pt.Op.intc, 4, "//", 2**7),
     ]
 
     actual = createConstantBlocks(ops)
@@ -633,36 +648,36 @@ def test_createConstantBlocks_intc():
 
 
 def test_createConstantBlocks_small_constant():
-    """If a constant cannot be referenced using the intc_[0..3] commands
-    and it can be stored in one varuint it byte then Op.pushint is used.
+    """pt.If a constant cannot be referenced using the intc_[0..3] commands
+    and it can be stored in one varuint it byte then pt.Op.pushint is used.
     """
 
     for cur in range(4, 2**7):
         ops = [
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.int, cur),
-            TealOp(None, Op.int, cur),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.int, cur),
+            pt.TealOp(None, pt.Op.int, cur),
         ]
 
         expected = [
-            TealOp(None, Op.intcblock, 0, 1, 2, 3),
-            TealOp(None, Op.intc_0, "//", 0),
-            TealOp(None, Op.intc_0, "//", 0),
-            TealOp(None, Op.intc_1, "//", 1),
-            TealOp(None, Op.intc_1, "//", 1),
-            TealOp(None, Op.intc_2, "//", 2),
-            TealOp(None, Op.intc_2, "//", 2),
-            TealOp(None, Op.intc_3, "//", 3),
-            TealOp(None, Op.intc_3, "//", 3),
-            TealOp(None, Op.pushint, cur, "//", cur),
-            TealOp(None, Op.pushint, cur, "//", cur),
+            pt.TealOp(None, pt.Op.intcblock, 0, 1, 2, 3),
+            pt.TealOp(None, pt.Op.intc_0, "//", 0),
+            pt.TealOp(None, pt.Op.intc_0, "//", 0),
+            pt.TealOp(None, pt.Op.intc_1, "//", 1),
+            pt.TealOp(None, pt.Op.intc_1, "//", 1),
+            pt.TealOp(None, pt.Op.intc_2, "//", 2),
+            pt.TealOp(None, pt.Op.intc_2, "//", 2),
+            pt.TealOp(None, pt.Op.intc_3, "//", 3),
+            pt.TealOp(None, pt.Op.intc_3, "//", 3),
+            pt.TealOp(None, pt.Op.pushint, cur, "//", cur),
+            pt.TealOp(None, pt.Op.pushint, cur, "//", cur),
         ]
 
         actual = createConstantBlocks(ops)
diff --git a/pyteal/compiler/flatten_test.py b/pyteal/compiler/flatten_test.py
index 792371cb8..089a6ea48 100644
--- a/pyteal/compiler/flatten_test.py
+++ b/pyteal/compiler/flatten_test.py
@@ -1,9 +1,6 @@
 from collections import OrderedDict
 
-from .. import *
-
-# this is not necessary but mypy complains if it's not included
-from ..ast import *
+import pyteal as pt
 
 from .flatten import flattenBlocks, flattenSubroutines
 
@@ -18,7 +15,7 @@ def test_flattenBlocks_none():
 
 
 def test_flattenBlocks_single_empty():
-    blocks = [TealSimpleBlock([])]
+    blocks = [pt.TealSimpleBlock([])]
 
     expected = []
     actual = flattenBlocks(blocks)
@@ -27,9 +24,9 @@ def test_flattenBlocks_single_empty():
 
 
 def test_flattenBlocks_single_one():
-    blocks = [TealSimpleBlock([TealOp(None, Op.int, 1)])]
+    blocks = [pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])]
 
-    expected = [TealOp(None, Op.int, 1)]
+    expected = [pt.TealOp(None, pt.Op.int, 1)]
     actual = flattenBlocks(blocks)
 
     assert actual == expected
@@ -37,23 +34,23 @@ def test_flattenBlocks_single_one():
 
 def test_flattenBlocks_single_many():
     blocks = [
-        TealSimpleBlock(
+        pt.TealSimpleBlock(
             [
-                TealOp(None, Op.int, 1),
-                TealOp(None, Op.int, 2),
-                TealOp(None, Op.int, 3),
-                TealOp(None, Op.add),
-                TealOp(None, Op.add),
+                pt.TealOp(None, pt.Op.int, 1),
+                pt.TealOp(None, pt.Op.int, 2),
+                pt.TealOp(None, pt.Op.int, 3),
+                pt.TealOp(None, pt.Op.add),
+                pt.TealOp(None, pt.Op.add),
             ]
         )
     ]
 
     expected = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.add),
-        TealOp(None, Op.add),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.add),
     ]
     actual = flattenBlocks(blocks)
 
@@ -61,25 +58,25 @@ def test_flattenBlocks_single_many():
 
 
 def test_flattenBlocks_sequence():
-    block5 = TealSimpleBlock([TealOp(None, Op.int, 5)])
-    block4 = TealSimpleBlock([TealOp(None, Op.int, 4)])
+    block5 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 5)])
+    block4 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 4)])
     block4.setNextBlock(block5)
-    block3 = TealSimpleBlock([TealOp(None, Op.int, 3)])
+    block3 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 3)])
     block3.setNextBlock(block4)
-    block2 = TealSimpleBlock([TealOp(None, Op.int, 2)])
+    block2 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 2)])
     block2.setNextBlock(block3)
-    block1 = TealSimpleBlock([TealOp(None, Op.int, 1)])
+    block1 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])
     block1.setNextBlock(block2)
     block1.addIncoming()
     block1.validateTree()
     blocks = [block1, block2, block3, block4, block5]
 
     expected = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.int, 4),
-        TealOp(None, Op.int, 5),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.int, 4),
+        pt.TealOp(None, pt.Op.int, 5),
     ]
     actual = flattenBlocks(blocks)
 
@@ -87,13 +84,13 @@ def test_flattenBlocks_sequence():
 
 
 def test_flattenBlocks_branch():
-    blockTrue = TealSimpleBlock(
-        [TealOp(None, Op.byte, '"true"'), TealOp(None, Op.return_)]
+    blockTrue = pt.TealSimpleBlock(
+        [pt.TealOp(None, pt.Op.byte, '"true"'), pt.TealOp(None, pt.Op.return_)]
     )
-    blockFalse = TealSimpleBlock(
-        [TealOp(None, Op.byte, '"false"'), TealOp(None, Op.return_)]
+    blockFalse = pt.TealSimpleBlock(
+        [pt.TealOp(None, pt.Op.byte, '"false"'), pt.TealOp(None, pt.Op.return_)]
     )
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
     block.addIncoming()
@@ -101,13 +98,13 @@ def test_flattenBlocks_branch():
     blocks = [block, blockFalse, blockTrue]
 
     expected = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.bnz, LabelReference("l2")),
-        TealOp(None, Op.byte, '"false"'),
-        TealOp(None, Op.return_),
-        TealLabel(None, LabelReference("l2")),
-        TealOp(None, Op.byte, '"true"'),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.bnz, pt.LabelReference("l2")),
+        pt.TealOp(None, pt.Op.byte, '"false"'),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, pt.LabelReference("l2")),
+        pt.TealOp(None, pt.Op.byte, '"true"'),
+        pt.TealOp(None, pt.Op.return_),
     ]
     actual = flattenBlocks(blocks)
 
@@ -115,13 +112,13 @@ def test_flattenBlocks_branch():
 
 
 def test_flattenBlocks_branch_equal_end_nodes():
-    blockTrueEnd = TealSimpleBlock([TealOp(None, Op.return_)])
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockTrueEnd = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.return_)])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockTrueEnd)
-    blockFalseEnd = TealSimpleBlock([TealOp(None, Op.return_)])
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
+    blockFalseEnd = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.return_)])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
     blockFalse.setNextBlock(blockFalseEnd)
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
     block.addIncoming()
@@ -129,13 +126,13 @@ def test_flattenBlocks_branch_equal_end_nodes():
     blocks = [block, blockFalse, blockFalseEnd, blockTrue, blockTrueEnd]
 
     expected = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.bnz, LabelReference("l3")),
-        TealOp(None, Op.byte, '"false"'),
-        TealOp(None, Op.return_),
-        TealLabel(None, LabelReference("l3")),
-        TealOp(None, Op.byte, '"true"'),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.bnz, pt.LabelReference("l3")),
+        pt.TealOp(None, pt.Op.byte, '"false"'),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, pt.LabelReference("l3")),
+        pt.TealOp(None, pt.Op.byte, '"true"'),
+        pt.TealOp(None, pt.Op.return_),
     ]
     actual = flattenBlocks(blocks)
 
@@ -143,12 +140,12 @@ def test_flattenBlocks_branch_equal_end_nodes():
 
 
 def test_flattenBlocks_branch_converge():
-    blockEnd = TealSimpleBlock([TealOp(None, Op.return_)])
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockEnd = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.return_)])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockEnd)
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
     blockFalse.setNextBlock(blockEnd)
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
     block.addIncoming()
@@ -156,14 +153,14 @@ def test_flattenBlocks_branch_converge():
     blocks = [block, blockFalse, blockTrue, blockEnd]
 
     expected = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.bnz, LabelReference("l2")),
-        TealOp(None, Op.byte, '"false"'),
-        TealOp(None, Op.b, LabelReference("l3")),
-        TealLabel(None, LabelReference("l2")),
-        TealOp(None, Op.byte, '"true"'),
-        TealLabel(None, LabelReference("l3")),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.bnz, pt.LabelReference("l2")),
+        pt.TealOp(None, pt.Op.byte, '"false"'),
+        pt.TealOp(None, pt.Op.b, pt.LabelReference("l3")),
+        pt.TealLabel(None, pt.LabelReference("l2")),
+        pt.TealOp(None, pt.Op.byte, '"true"'),
+        pt.TealLabel(None, pt.LabelReference("l3")),
+        pt.TealOp(None, pt.Op.return_),
     ]
     actual = flattenBlocks(blocks)
 
@@ -171,21 +168,21 @@ def test_flattenBlocks_branch_converge():
 
 
 def test_flattenBlocks_multiple_branch():
-    blockTrueTrue = TealSimpleBlock(
-        [TealOp(None, Op.byte, '"true true"'), TealOp(None, Op.return_)]
+    blockTrueTrue = pt.TealSimpleBlock(
+        [pt.TealOp(None, pt.Op.byte, '"true true"'), pt.TealOp(None, pt.Op.return_)]
     )
-    blockTrueFalse = TealSimpleBlock(
-        [TealOp(None, Op.byte, '"true false"'), TealOp(None, Op.err)]
+    blockTrueFalse = pt.TealSimpleBlock(
+        [pt.TealOp(None, pt.Op.byte, '"true false"'), pt.TealOp(None, pt.Op.err)]
     )
-    blockTrueBranch = TealConditionalBlock([])
+    blockTrueBranch = pt.TealConditionalBlock([])
     blockTrueBranch.setTrueBlock(blockTrueTrue)
     blockTrueBranch.setFalseBlock(blockTrueFalse)
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockTrueBranch)
-    blockFalse = TealSimpleBlock(
-        [TealOp(None, Op.byte, '"false"'), TealOp(None, Op.return_)]
+    blockFalse = pt.TealSimpleBlock(
+        [pt.TealOp(None, pt.Op.byte, '"false"'), pt.TealOp(None, pt.Op.return_)]
     )
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
     block.addIncoming()
@@ -200,18 +197,18 @@ def test_flattenBlocks_multiple_branch():
     ]
 
     expected = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.bnz, LabelReference("l2")),
-        TealOp(None, Op.byte, '"false"'),
-        TealOp(None, Op.return_),
-        TealLabel(None, LabelReference("l2")),
-        TealOp(None, Op.byte, '"true"'),
-        TealOp(None, Op.bnz, LabelReference("l5")),
-        TealOp(None, Op.byte, '"true false"'),
-        TealOp(None, Op.err),
-        TealLabel(None, LabelReference("l5")),
-        TealOp(None, Op.byte, '"true true"'),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.bnz, pt.LabelReference("l2")),
+        pt.TealOp(None, pt.Op.byte, '"false"'),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, pt.LabelReference("l2")),
+        pt.TealOp(None, pt.Op.byte, '"true"'),
+        pt.TealOp(None, pt.Op.bnz, pt.LabelReference("l5")),
+        pt.TealOp(None, pt.Op.byte, '"true false"'),
+        pt.TealOp(None, pt.Op.err),
+        pt.TealLabel(None, pt.LabelReference("l5")),
+        pt.TealOp(None, pt.Op.byte, '"true true"'),
+        pt.TealOp(None, pt.Op.return_),
     ]
     actual = flattenBlocks(blocks)
 
@@ -219,20 +216,20 @@ def test_flattenBlocks_multiple_branch():
 
 
 def test_flattenBlocks_multiple_branch_converge():
-    blockEnd = TealSimpleBlock([TealOp(None, Op.return_)])
-    blockTrueTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true true"')])
+    blockEnd = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.return_)])
+    blockTrueTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true true"')])
     blockTrueTrue.setNextBlock(blockEnd)
-    blockTrueFalse = TealSimpleBlock(
-        [TealOp(None, Op.byte, '"true false"'), TealOp(None, Op.err)]
+    blockTrueFalse = pt.TealSimpleBlock(
+        [pt.TealOp(None, pt.Op.byte, '"true false"'), pt.TealOp(None, pt.Op.err)]
     )
-    blockTrueBranch = TealConditionalBlock([])
+    blockTrueBranch = pt.TealConditionalBlock([])
     blockTrueBranch.setTrueBlock(blockTrueTrue)
     blockTrueBranch.setFalseBlock(blockTrueFalse)
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockTrueBranch)
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
     blockFalse.setNextBlock(blockEnd)
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
     block.addIncoming()
@@ -248,19 +245,19 @@ def test_flattenBlocks_multiple_branch_converge():
     ]
 
     expected = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.bnz, LabelReference("l2")),
-        TealOp(None, Op.byte, '"false"'),
-        TealOp(None, Op.b, LabelReference("l6")),
-        TealLabel(None, LabelReference("l2")),
-        TealOp(None, Op.byte, '"true"'),
-        TealOp(None, Op.bnz, LabelReference("l5")),
-        TealOp(None, Op.byte, '"true false"'),
-        TealOp(None, Op.err),
-        TealLabel(None, LabelReference("l5")),
-        TealOp(None, Op.byte, '"true true"'),
-        TealLabel(None, LabelReference("l6")),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.bnz, pt.LabelReference("l2")),
+        pt.TealOp(None, pt.Op.byte, '"false"'),
+        pt.TealOp(None, pt.Op.b, pt.LabelReference("l6")),
+        pt.TealLabel(None, pt.LabelReference("l2")),
+        pt.TealOp(None, pt.Op.byte, '"true"'),
+        pt.TealOp(None, pt.Op.bnz, pt.LabelReference("l5")),
+        pt.TealOp(None, pt.Op.byte, '"true false"'),
+        pt.TealOp(None, pt.Op.err),
+        pt.TealLabel(None, pt.LabelReference("l5")),
+        pt.TealOp(None, pt.Op.byte, '"true true"'),
+        pt.TealLabel(None, pt.LabelReference("l6")),
+        pt.TealOp(None, pt.Op.return_),
     ]
     actual = flattenBlocks(blocks)
 
@@ -270,32 +267,32 @@ def test_flattenBlocks_multiple_branch_converge():
 def test_flattenSubroutines_no_subroutines():
     subroutineToLabel = OrderedDict()
 
-    l1Label = LabelReference("l1")
+    l1Label = pt.LabelReference("l1")
     mainOps = [
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {None: mainOps}
 
-    expectedL1Label = LabelReference("main_l1")
+    expectedL1Label = pt.LabelReference("main_l1")
     expected = [
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, expectedL1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.return_),
-        TealLabel(None, expectedL1Label),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, expectedL1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, expectedL1Label),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     actual = flattenSubroutines(subroutineMapping, subroutineToLabel)
@@ -304,55 +301,57 @@ def test_flattenSubroutines_no_subroutines():
 
 
 def test_flattenSubroutines_1_subroutine():
-    subroutine = SubroutineDefinition(lambda: Int(1) + Int(2) + Int(3), TealType.uint64)
+    subroutine = pt.SubroutineDefinition(
+        lambda: pt.Int(1) + pt.Int(2) + pt.Int(3), pt.TealType.uint64
+    )
 
     subroutineToLabel = OrderedDict()
     subroutineToLabel[subroutine] = "sub0"
 
-    subroutineLabel = LabelReference(subroutineToLabel[subroutine])
+    subroutineLabel = pt.LabelReference(subroutineToLabel[subroutine])
     subroutineOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.add),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    l1Label = LabelReference("l1")
+    l1Label = pt.LabelReference("l1")
     mainOps = [
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.callsub, subroutineLabel),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.callsub, subroutineLabel),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {None: mainOps, subroutine: subroutineOps}
 
-    expectedL1Label = LabelReference("main_l1")
-    expectedSubroutineLabel = LabelReference("sub0")
+    expectedL1Label = pt.LabelReference("main_l1")
+    expectedSubroutineLabel = pt.LabelReference("sub0")
     expected = [
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, expectedL1Label),
-        TealOp(None, Op.callsub, expectedSubroutineLabel),
-        TealOp(None, Op.return_),
-        TealLabel(None, expectedL1Label),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.return_),
-        TealLabel(None, expectedSubroutineLabel, "<lambda>"),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.add),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, expectedL1Label),
+        pt.TealOp(None, pt.Op.callsub, expectedSubroutineLabel),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, expectedL1Label),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, expectedSubroutineLabel, "<lambda>"),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     actual = flattenSubroutines(subroutineMapping, subroutineToLabel)
@@ -370,93 +369,93 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
     subroutineToLabel = OrderedDict()
     subroutineToLabel[subroutine1] = "sub0"
     subroutineToLabel[subroutine2] = "sub1"
     subroutineToLabel[subroutine3] = "sub2"
 
-    subroutine1Label = LabelReference(subroutineToLabel[subroutine1])
+    subroutine1Label = pt.LabelReference(subroutineToLabel[subroutine1])
     subroutine1Ops = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.add),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2Label = LabelReference(subroutineToLabel[subroutine2])
-    subroutine2L1Label = LabelReference("l1")
-    subroutine2L2Label = LabelReference("l2")
-    subroutine2L3Label = LabelReference("l3")
-    subroutine2L4Label = LabelReference("l4")
+    subroutine2Label = pt.LabelReference(subroutineToLabel[subroutine2])
+    subroutine2L1Label = pt.LabelReference("l1")
+    subroutine2L2Label = pt.LabelReference("l2")
+    subroutine2L3Label = pt.LabelReference("l3")
+    subroutine2L4Label = pt.LabelReference("l4")
     subroutine2Ops = [
-        TealOp(None, Op.dup),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine2L1Label),
-        TealOp(None, Op.dup),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine2L2Label),
-        TealOp(None, Op.dup),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine2L3Label),
-        TealOp(None, Op.dup),
-        TealOp(None, Op.int, 4),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine2L4Label),
-        TealOp(None, Op.err),
-        TealLabel(None, subroutine2L1Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.byte, '"1"'),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine2L2Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.byte, '"2"'),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine2L3Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.byte, '"3"'),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine2L4Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.byte, '"4"'),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.dup),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.dup),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine2L2Label),
+        pt.TealOp(None, pt.Op.dup),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine2L3Label),
+        pt.TealOp(None, pt.Op.dup),
+        pt.TealOp(None, pt.Op.int, 4),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine2L4Label),
+        pt.TealOp(None, pt.Op.err),
+        pt.TealLabel(None, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.byte, '"1"'),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine2L2Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.byte, '"2"'),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine2L3Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.byte, '"3"'),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine2L4Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.byte, '"4"'),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine3Label = LabelReference(subroutineToLabel[subroutine3])
-    subroutine3L1Label = LabelReference("l1")
+    subroutine3Label = pt.LabelReference(subroutineToLabel[subroutine3])
+    subroutine3L1Label = pt.LabelReference("l1")
     subroutine3Ops = [
-        TealLabel(None, subroutine3L1Label),
-        TealOp(None, Op.app_local_put),
-        TealOp(None, Op.retsub),
-        TealOp(None, Op.b, subroutine3L1Label),
+        pt.TealLabel(None, subroutine3L1Label),
+        pt.TealOp(None, pt.Op.app_local_put),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealOp(None, pt.Op.b, subroutine3L1Label),
     ]
 
-    l1Label = LabelReference("l1")
+    l1Label = pt.LabelReference("l1")
     mainOps = [
-        TealOp(None, Op.byte, '"account"'),
-        TealOp(None, Op.byte, '"key"'),
-        TealOp(None, Op.byte, '"value"'),
-        TealOp(None, Op.callsub, subroutine3Label),
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine2Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.callsub, subroutine1Label),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.byte, '"account"'),
+        pt.TealOp(None, pt.Op.byte, '"key"'),
+        pt.TealOp(None, pt.Op.byte, '"value"'),
+        pt.TealOp(None, pt.Op.callsub, subroutine3Label),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine2Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.callsub, subroutine1Label),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {
@@ -466,78 +465,78 @@ def sub3Impl(a1, a2, a3):
         subroutine3: subroutine3Ops,
     }
 
-    expectedL1Label = LabelReference("main_l1")
-    expectedSubroutine1Label = LabelReference("sub0")
-    expectedSubroutine2Label = LabelReference("sub1")
-    expectedSubroutine2L1Label = LabelReference("sub1_l1")
-    expectedSubroutine2L2Label = LabelReference("sub1_l2")
-    expectedSubroutine2L3Label = LabelReference("sub1_l3")
-    expectedSubroutine2L4Label = LabelReference("sub1_l4")
-    expectedSubroutine3Label = LabelReference("sub2")
-    expectedSubroutine3L1Label = LabelReference("sub2_l1")
+    expectedL1Label = pt.LabelReference("main_l1")
+    expectedSubroutine1Label = pt.LabelReference("sub0")
+    expectedSubroutine2Label = pt.LabelReference("sub1")
+    expectedSubroutine2L1Label = pt.LabelReference("sub1_l1")
+    expectedSubroutine2L2Label = pt.LabelReference("sub1_l2")
+    expectedSubroutine2L3Label = pt.LabelReference("sub1_l3")
+    expectedSubroutine2L4Label = pt.LabelReference("sub1_l4")
+    expectedSubroutine3Label = pt.LabelReference("sub2")
+    expectedSubroutine3L1Label = pt.LabelReference("sub2_l1")
     expected = [
-        TealOp(None, Op.byte, '"account"'),
-        TealOp(None, Op.byte, '"key"'),
-        TealOp(None, Op.byte, '"value"'),
-        TealOp(None, Op.callsub, subroutine3Label),
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine2Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.callsub, subroutine1Label),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.return_),
-        TealLabel(None, expectedSubroutine1Label, "sub1Impl"),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.add),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, expectedSubroutine2Label, "sub2Impl"),
-        TealOp(None, Op.dup),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, expectedSubroutine2L1Label),
-        TealOp(None, Op.dup),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, expectedSubroutine2L2Label),
-        TealOp(None, Op.dup),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, expectedSubroutine2L3Label),
-        TealOp(None, Op.dup),
-        TealOp(None, Op.int, 4),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, expectedSubroutine2L4Label),
-        TealOp(None, Op.err),
-        TealLabel(None, expectedSubroutine2L1Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.byte, '"1"'),
-        TealOp(None, Op.retsub),
-        TealLabel(None, expectedSubroutine2L2Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.byte, '"2"'),
-        TealOp(None, Op.retsub),
-        TealLabel(None, expectedSubroutine2L3Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.byte, '"3"'),
-        TealOp(None, Op.retsub),
-        TealLabel(None, expectedSubroutine2L4Label),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.byte, '"4"'),
-        TealOp(None, Op.retsub),
-        TealLabel(None, expectedSubroutine3Label, "sub3Impl"),
-        TealLabel(None, expectedSubroutine3L1Label),
-        TealOp(None, Op.app_local_put),
-        TealOp(None, Op.retsub),
-        TealOp(None, Op.b, expectedSubroutine3L1Label),
+        pt.TealOp(None, pt.Op.byte, '"account"'),
+        pt.TealOp(None, pt.Op.byte, '"key"'),
+        pt.TealOp(None, pt.Op.byte, '"value"'),
+        pt.TealOp(None, pt.Op.callsub, subroutine3Label),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, expectedL1Label),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine2Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.callsub, subroutine1Label),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, expectedL1Label),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, expectedSubroutine1Label, "sub1Impl"),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, expectedSubroutine2Label, "sub2Impl"),
+        pt.TealOp(None, pt.Op.dup),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, expectedSubroutine2L1Label),
+        pt.TealOp(None, pt.Op.dup),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, expectedSubroutine2L2Label),
+        pt.TealOp(None, pt.Op.dup),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, expectedSubroutine2L3Label),
+        pt.TealOp(None, pt.Op.dup),
+        pt.TealOp(None, pt.Op.int, 4),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, expectedSubroutine2L4Label),
+        pt.TealOp(None, pt.Op.err),
+        pt.TealLabel(None, expectedSubroutine2L1Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.byte, '"1"'),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, expectedSubroutine2L2Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.byte, '"2"'),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, expectedSubroutine2L3Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.byte, '"3"'),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, expectedSubroutine2L4Label),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.byte, '"4"'),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, expectedSubroutine3Label, "sub3Impl"),
+        pt.TealLabel(None, expectedSubroutine3L1Label),
+        pt.TealOp(None, pt.Op.app_local_put),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealOp(None, pt.Op.b, expectedSubroutine3L1Label),
     ]
 
     actual = flattenSubroutines(subroutineMapping, subroutineToLabel)
diff --git a/pyteal/compiler/optimizer/optimizer_test.py b/pyteal/compiler/optimizer/optimizer_test.py
index 05d61f312..9da93bb88 100644
--- a/pyteal/compiler/optimizer/optimizer_test.py
+++ b/pyteal/compiler/optimizer/optimizer_test.py
@@ -1,79 +1,79 @@
 from .optimizer import OptimizeOptions, _apply_slot_to_stack
 
-from ... import *
-
-import pytest
+import pyteal as pt
 
 
 def test_optimize_single_block():
-    slot1 = ScratchSlot(1)
-    slot2 = ScratchSlot(2)
+    slot1 = pt.ScratchSlot(1)
+    slot2 = pt.ScratchSlot(2)
 
     # empty check
-    empty_block = TealSimpleBlock([])
+    empty_block = pt.TealSimpleBlock([])
     _apply_slot_to_stack(empty_block, empty_block, {})
 
-    expected = TealSimpleBlock([])
+    expected = pt.TealSimpleBlock([])
     assert empty_block == expected
 
     # basic optimization
-    block = TealSimpleBlock(
+    block = pt.TealSimpleBlock(
         [
-            TealOp(None, Op.store, slot1),
-            TealOp(None, Op.load, slot1),
+            pt.TealOp(None, pt.Op.store, slot1),
+            pt.TealOp(None, pt.Op.load, slot1),
         ]
     )
     _apply_slot_to_stack(block, block, {})
 
-    expected = TealSimpleBlock([])
+    expected = pt.TealSimpleBlock([])
     assert block == expected
 
     # iterate optimization
-    block = TealSimpleBlock(
+    block = pt.TealSimpleBlock(
         [
-            TealOp(None, Op.store, slot1),
-            TealOp(None, Op.store, slot2),
-            TealOp(None, Op.load, slot2),
-            TealOp(None, Op.load, slot1),
+            pt.TealOp(None, pt.Op.store, slot1),
+            pt.TealOp(None, pt.Op.store, slot2),
+            pt.TealOp(None, pt.Op.load, slot2),
+            pt.TealOp(None, pt.Op.load, slot1),
         ]
     )
     _apply_slot_to_stack(block, block, {})
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(None, Op.store, slot1),
-            TealOp(None, Op.load, slot1),
+            pt.TealOp(None, pt.Op.store, slot1),
+            pt.TealOp(None, pt.Op.load, slot1),
         ]
     )
     assert block == expected
 
     _apply_slot_to_stack(block, block, {})
-    expected = TealSimpleBlock([])
+    expected = pt.TealSimpleBlock([])
     assert block == expected
 
     # remove extraneous stores
-    block = TealSimpleBlock(
+    block = pt.TealSimpleBlock(
         [
-            TealOp(None, Op.store, slot1),
-            TealOp(None, Op.load, slot1),
-            TealOp(None, Op.store, slot1),
+            pt.TealOp(None, pt.Op.store, slot1),
+            pt.TealOp(None, pt.Op.load, slot1),
+            pt.TealOp(None, pt.Op.store, slot1),
         ]
     )
     _apply_slot_to_stack(block, block, {})
 
-    expected = TealSimpleBlock([])
+    expected = pt.TealSimpleBlock([])
     assert block == expected
 
 
 def test_optimize_subroutine():
-    @Subroutine(TealType.uint64)
-    def add(a1: Expr, a2: Expr) -> Expr:
+    @pt.Subroutine(pt.TealType.uint64)
+    def add(a1: pt.Expr, a2: pt.Expr) -> pt.Expr:
         return a1 + a2
 
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.sender() == Global.creator_address()).Then(Pop(add(Int(1), Int(2)))),
-            Approve(),
+            pt.If(pt.Txn.sender() == pt.Global.creator_address()).Then(
+                pt.Pop(add(pt.Int(1), pt.Int(2)))
+            ),
+            pt.Approve(),
         ]
     )
 
@@ -102,8 +102,8 @@ def add(a1: Expr, a2: Expr) -> Expr:
 +
 retsub
     """.strip()
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
@@ -127,24 +127,26 @@ def add(a1: Expr, a2: Expr) -> Expr:
 retsub
     """.strip()
     optimize_options = OptimizeOptions(scratch_slots=True)
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
 
 def test_optimize_subroutine_with_scratchvar_arg():
-    @Subroutine(TealType.uint64)
-    def add(a1: ScratchVar, a2: Expr) -> Expr:
+    @pt.Subroutine(pt.TealType.uint64)
+    def add(a1: pt.ScratchVar, a2: pt.Expr) -> pt.Expr:
         return a1.load() + a2
 
-    arg = ScratchVar(TealType.uint64)
+    arg = pt.ScratchVar(pt.TealType.uint64)
 
-    program = Seq(
+    program = pt.Seq(
         [
-            arg.store(Int(1)),
-            If(Txn.sender() == Global.creator_address()).Then(Pop(add(arg, Int(2)))),
-            Approve(),
+            arg.store(pt.Int(1)),
+            pt.If(pt.Txn.sender() == pt.Global.creator_address()).Then(
+                pt.Pop(add(arg, pt.Int(2)))
+            ),
+            pt.Approve(),
         ]
     )
 
@@ -175,8 +177,8 @@ def add(a1: ScratchVar, a2: Expr) -> Expr:
 load 2
 +
 retsub""".strip()
-    actual = compileTeal(
-        program, version=5, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=5, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
@@ -204,23 +206,25 @@ def add(a1: ScratchVar, a2: Expr) -> Expr:
 +
 retsub""".strip()
     optimize_options = OptimizeOptions(scratch_slots=True)
-    actual = compileTeal(
-        program, version=5, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=5, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
 
 def test_optimize_subroutine_with_local_var():
-    local_var = ScratchVar(TealType.uint64)
+    local_var = pt.ScratchVar(pt.TealType.uint64)
 
-    @Subroutine(TealType.uint64)
-    def add(a1: Expr) -> Expr:
-        return Seq(local_var.store(Int(2)), local_var.load() + a1)
+    @pt.Subroutine(pt.TealType.uint64)
+    def add(a1: pt.Expr) -> pt.Expr:
+        return pt.Seq(local_var.store(pt.Int(2)), local_var.load() + a1)
 
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.sender() == Global.creator_address()).Then(Pop(add(Int(1)))),
-            Approve(),
+            pt.If(pt.Txn.sender() == pt.Global.creator_address()).Then(
+                pt.Pop(add(pt.Int(1)))
+            ),
+            pt.Approve(),
         ]
     )
 
@@ -249,8 +253,8 @@ def add(a1: Expr) -> Expr:
 +
 retsub
     """.strip()
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
@@ -276,24 +280,26 @@ def add(a1: Expr) -> Expr:
 retsub
     """.strip()
     optimize_options = OptimizeOptions(scratch_slots=True)
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
 
 def test_optimize_subroutine_with_global_var():
-    global_var = ScratchVar(TealType.uint64)
+    global_var = pt.ScratchVar(pt.TealType.uint64)
 
-    @Subroutine(TealType.uint64)
-    def add(a1: Expr) -> Expr:
-        return Seq(global_var.store(Int(2)), global_var.load() + a1)
+    @pt.Subroutine(pt.TealType.uint64)
+    def add(a1: pt.Expr) -> pt.Expr:
+        return pt.Seq(global_var.store(pt.Int(2)), global_var.load() + a1)
 
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.sender() == Global.creator_address()).Then(Pop(add(Int(1)))),
-            global_var.store(Int(5)),
-            Approve(),
+            pt.If(pt.Txn.sender() == pt.Global.creator_address()).Then(
+                pt.Pop(add(pt.Int(1)))
+            ),
+            global_var.store(pt.Int(5)),
+            pt.Approve(),
         ]
     )
 
@@ -324,30 +330,32 @@ def add(a1: Expr) -> Expr:
 +
 retsub
     """.strip()
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
     # optimization should not apply to global vars
     optimize_options = OptimizeOptions(scratch_slots=True)
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
 
 def test_optimize_subroutine_with_reserved_local_var():
-    local_var = ScratchVar(TealType.uint64, 0)
+    local_var = pt.ScratchVar(pt.TealType.uint64, 0)
 
-    @Subroutine(TealType.uint64)
-    def add(a1: Expr) -> Expr:
-        return Seq(local_var.store(Int(2)), local_var.load() + a1)
+    @pt.Subroutine(pt.TealType.uint64)
+    def add(a1: pt.Expr) -> pt.Expr:
+        return pt.Seq(local_var.store(pt.Int(2)), local_var.load() + a1)
 
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.sender() == Global.creator_address()).Then(Pop(add(Int(1)))),
-            Approve(),
+            pt.If(pt.Txn.sender() == pt.Global.creator_address()).Then(
+                pt.Pop(add(pt.Int(1)))
+            ),
+            pt.Approve(),
         ]
     )
 
@@ -376,29 +384,31 @@ def add(a1: Expr) -> Expr:
 +
 retsub
     """.strip()
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
     # The optimization must skip over the reserved slot id so the expected result
     # hasn't changed.
     optimize_options = OptimizeOptions(scratch_slots=True)
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
 
 def test_optimize_subroutine_with_load_dependency():
-    @Subroutine(TealType.uint64)
-    def add(a1: Expr, a2: Expr) -> Expr:
-        return Seq(Pop(a1 + a2), a2)
+    @pt.Subroutine(pt.TealType.uint64)
+    def add(a1: pt.Expr, a2: pt.Expr) -> pt.Expr:
+        return pt.Seq(pt.Pop(a1 + a2), a2)
 
-    program = Seq(
+    program = pt.Seq(
         [
-            If(Txn.sender() == Global.creator_address()).Then(Pop(add(Int(1), Int(2)))),
-            Approve(),
+            pt.If(pt.Txn.sender() == pt.Global.creator_address()).Then(
+                pt.Pop(add(pt.Int(1), pt.Int(2)))
+            ),
+            pt.Approve(),
         ]
     )
 
@@ -428,8 +438,8 @@ def add(a1: Expr, a2: Expr) -> Expr:
 pop
 load 1
 retsub""".strip()
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
@@ -457,22 +467,22 @@ def add(a1: Expr, a2: Expr) -> Expr:
 load 0
 retsub""".strip()
     optimize_options = OptimizeOptions(scratch_slots=True)
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
 
 def test_optimize_multi_value():
     # note: this is incorrect usage of the app_global_get_ex opcode
-    program = Seq(
-        MultiValue(
-            Op.app_global_get_ex,
-            [TealType.uint64, TealType.uint64],
+    program = pt.Seq(
+        pt.MultiValue(
+            pt.Op.app_global_get_ex,
+            [pt.TealType.uint64, pt.TealType.uint64],
             immediate_args=[],
-            args=[Int(0), Int(1)],
-        ).outputReducer(lambda value, hasValue: Pop(value + hasValue)),
-        Approve(),
+            args=[pt.Int(0), pt.Int(1)],
+        ).outputReducer(lambda value, hasValue: pt.Pop(value + hasValue)),
+        pt.Approve(),
     )
 
     optimize_options = OptimizeOptions()
@@ -490,8 +500,8 @@ def test_optimize_multi_value():
 pop
 int 1
 return""".strip()
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
@@ -505,21 +515,21 @@ def test_optimize_multi_value():
 int 1
 return""".strip()
     optimize_options = OptimizeOptions(scratch_slots=True)
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
 
 def test_optimize_dynamic_var():
-    myvar = DynamicScratchVar()
-    regvar = ScratchVar()
-    program = Seq(
-        regvar.store(Int(1)),
+    myvar = pt.DynamicScratchVar()
+    regvar = pt.ScratchVar()
+    program = pt.Seq(
+        regvar.store(pt.Int(1)),
         myvar.set_index(regvar),
-        regvar.store(Int(2)),
-        Pop(regvar.load()),
-        Approve(),
+        regvar.store(pt.Int(2)),
+        pt.Pop(regvar.load()),
+        pt.Approve(),
     )
 
     optimize_options = OptimizeOptions()
@@ -536,15 +546,15 @@ def test_optimize_dynamic_var():
 pop
 int 1
 return""".strip()
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
 
     # optimization should not change the code because the candidate slot
     # is used by the dynamic slot variable.
     optimize_options = OptimizeOptions(scratch_slots=True)
-    actual = compileTeal(
-        program, version=4, mode=Mode.Application, optimize=optimize_options
+    actual = pt.compileTeal(
+        program, version=4, mode=pt.Mode.Application, optimize=optimize_options
     )
     assert actual == expected
diff --git a/pyteal/compiler/scratchslots_test.py b/pyteal/compiler/scratchslots_test.py
index d5155c235..a9b545d26 100644
--- a/pyteal/compiler/scratchslots_test.py
+++ b/pyteal/compiler/scratchslots_test.py
@@ -1,6 +1,6 @@
 import pytest
 
-from .. import *
+import pyteal as pt
 
 from .scratchslots import collectScratchSlots, assignScratchSlotsToSubroutines
 
@@ -15,53 +15,53 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
-    globalSlot1 = ScratchSlot()
+    globalSlot1 = pt.ScratchSlot()
 
-    subroutine1Slot1 = ScratchSlot()
-    subroutine1Slot2 = ScratchSlot()
+    subroutine1Slot1 = pt.ScratchSlot()
+    subroutine1Slot2 = pt.ScratchSlot()
     subroutine1Ops = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, subroutine1Slot1),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.store, subroutine1Slot2),
-        TealOp(None, Op.load, globalSlot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot1),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot2),
+        pt.TealOp(None, pt.Op.load, globalSlot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2Slot1 = ScratchSlot()
+    subroutine2Slot1 = pt.ScratchSlot()
     subroutine2Ops = [
-        TealOp(None, Op.byte, '"value"'),
-        TealOp(None, Op.store, subroutine2Slot1),
-        TealOp(None, Op.load, subroutine2Slot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.byte, '"value"'),
+        pt.TealOp(None, pt.Op.store, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.load, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     subroutine3Ops = [
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    mainSlot1 = ScratchSlot()
-    mainSlot2 = ScratchSlot()
+    mainSlot1 = pt.ScratchSlot()
+    mainSlot2 = pt.ScratchSlot()
     mainOps = [
-        TealOp(None, Op.int, 7),
-        TealOp(None, Op.store, globalSlot1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, mainSlot1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.store, mainSlot2),
-        TealOp(None, Op.load, mainSlot1),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 7),
+        pt.TealOp(None, pt.Op.store, globalSlot1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, mainSlot1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.store, mainSlot2),
+        pt.TealOp(None, pt.Op.load, mainSlot1),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineBlocks = {
-        None: TealSimpleBlock(mainOps),
-        subroutine1: TealSimpleBlock(subroutine1Ops),
-        subroutine2: TealSimpleBlock(subroutine2Ops),
-        subroutine3: TealSimpleBlock(subroutine3Ops),
+        None: pt.TealSimpleBlock(mainOps),
+        subroutine1: pt.TealSimpleBlock(subroutine1Ops),
+        subroutine2: pt.TealSimpleBlock(subroutine2Ops),
+        subroutine3: pt.TealSimpleBlock(subroutine3Ops),
     }
 
     expected_global = {globalSlot1}
@@ -89,53 +89,53 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
-    globalSlot1 = ScratchSlot()
+    globalSlot1 = pt.ScratchSlot()
 
-    subroutine1Slot1 = ScratchSlot()
-    subroutine1Slot2 = ScratchSlot()
+    subroutine1Slot1 = pt.ScratchSlot()
+    subroutine1Slot2 = pt.ScratchSlot()
     subroutine1Ops = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, subroutine1Slot1),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.store, subroutine1Slot2),
-        TealOp(None, Op.load, globalSlot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot1),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot2),
+        pt.TealOp(None, pt.Op.load, globalSlot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2Slot1 = ScratchSlot()
+    subroutine2Slot1 = pt.ScratchSlot()
     subroutine2Ops = [
-        TealOp(None, Op.byte, '"value"'),
-        TealOp(None, Op.store, subroutine2Slot1),
-        TealOp(None, Op.load, subroutine2Slot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.byte, '"value"'),
+        pt.TealOp(None, pt.Op.store, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.load, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     subroutine3Ops = [
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    mainSlot1 = ScratchSlot()
-    mainSlot2 = ScratchSlot()
+    mainSlot1 = pt.ScratchSlot()
+    mainSlot2 = pt.ScratchSlot()
     mainOps = [
-        TealOp(None, Op.int, 7),
-        TealOp(None, Op.store, globalSlot1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, mainSlot1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.store, mainSlot2),
-        TealOp(None, Op.load, mainSlot1),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 7),
+        pt.TealOp(None, pt.Op.store, globalSlot1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, mainSlot1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.store, mainSlot2),
+        pt.TealOp(None, pt.Op.load, mainSlot1),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineBlocks = {
-        None: TealSimpleBlock(mainOps),
-        subroutine1: TealSimpleBlock(subroutine1Ops),
-        subroutine2: TealSimpleBlock(subroutine2Ops),
-        subroutine3: TealSimpleBlock(subroutine3Ops),
+        None: pt.TealSimpleBlock(mainOps),
+        subroutine1: pt.TealSimpleBlock(subroutine1Ops),
+        subroutine2: pt.TealSimpleBlock(subroutine2Ops),
+        subroutine3: pt.TealSimpleBlock(subroutine3Ops),
     }
 
     expectedAssignments = {
@@ -162,34 +162,34 @@ def sub3Impl(a1, a2, a3):
     assert actual == expected
 
     assert subroutine1Ops == [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, expectedAssignments[subroutine1Slot1]),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.store, expectedAssignments[subroutine1Slot2]),
-        TealOp(None, Op.load, expectedAssignments[globalSlot1]),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[subroutine1Slot1]),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[subroutine1Slot2]),
+        pt.TealOp(None, pt.Op.load, expectedAssignments[globalSlot1]),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     assert subroutine2Ops == [
-        TealOp(None, Op.byte, '"value"'),
-        TealOp(None, Op.store, expectedAssignments[subroutine2Slot1]),
-        TealOp(None, Op.load, expectedAssignments[subroutine2Slot1]),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.byte, '"value"'),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[subroutine2Slot1]),
+        pt.TealOp(None, pt.Op.load, expectedAssignments[subroutine2Slot1]),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     assert subroutine3Ops == [
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     assert mainOps == [
-        TealOp(None, Op.int, 7),
-        TealOp(None, Op.store, expectedAssignments[globalSlot1]),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, expectedAssignments[mainSlot1]),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.store, expectedAssignments[mainSlot2]),
-        TealOp(None, Op.load, expectedAssignments[mainSlot1]),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 7),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[globalSlot1]),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[mainSlot1]),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[mainSlot2]),
+        pt.TealOp(None, pt.Op.load, expectedAssignments[mainSlot1]),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
 
@@ -203,53 +203,53 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
-    globalSlot1 = ScratchSlot(requestedSlotId=8)
+    globalSlot1 = pt.ScratchSlot(requestedSlotId=8)
 
-    subroutine1Slot1 = ScratchSlot()
-    subroutine1Slot2 = ScratchSlot(requestedSlotId=5)
+    subroutine1Slot1 = pt.ScratchSlot()
+    subroutine1Slot2 = pt.ScratchSlot(requestedSlotId=5)
     subroutine1Ops = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, subroutine1Slot1),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.store, subroutine1Slot2),
-        TealOp(None, Op.load, globalSlot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot1),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot2),
+        pt.TealOp(None, pt.Op.load, globalSlot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2Slot1 = ScratchSlot()
+    subroutine2Slot1 = pt.ScratchSlot()
     subroutine2Ops = [
-        TealOp(None, Op.byte, '"value"'),
-        TealOp(None, Op.store, subroutine2Slot1),
-        TealOp(None, Op.load, subroutine2Slot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.byte, '"value"'),
+        pt.TealOp(None, pt.Op.store, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.load, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     subroutine3Ops = [
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    mainSlot1 = ScratchSlot()
-    mainSlot2 = ScratchSlot(requestedSlotId=100)
+    mainSlot1 = pt.ScratchSlot()
+    mainSlot2 = pt.ScratchSlot(requestedSlotId=100)
     mainOps = [
-        TealOp(None, Op.int, 7),
-        TealOp(None, Op.store, globalSlot1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, mainSlot1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.store, mainSlot2),
-        TealOp(None, Op.load, mainSlot1),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 7),
+        pt.TealOp(None, pt.Op.store, globalSlot1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, mainSlot1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.store, mainSlot2),
+        pt.TealOp(None, pt.Op.load, mainSlot1),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineBlocks = {
-        None: TealSimpleBlock(mainOps),
-        subroutine1: TealSimpleBlock(subroutine1Ops),
-        subroutine2: TealSimpleBlock(subroutine2Ops),
-        subroutine3: TealSimpleBlock(subroutine3Ops),
+        None: pt.TealSimpleBlock(mainOps),
+        subroutine1: pt.TealSimpleBlock(subroutine1Ops),
+        subroutine2: pt.TealSimpleBlock(subroutine2Ops),
+        subroutine3: pt.TealSimpleBlock(subroutine3Ops),
     }
 
     expectedAssignments = {
@@ -276,34 +276,34 @@ def sub3Impl(a1, a2, a3):
     assert actual == expected
 
     assert subroutine1Ops == [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, expectedAssignments[subroutine1Slot1]),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.store, expectedAssignments[subroutine1Slot2]),
-        TealOp(None, Op.load, expectedAssignments[globalSlot1]),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[subroutine1Slot1]),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[subroutine1Slot2]),
+        pt.TealOp(None, pt.Op.load, expectedAssignments[globalSlot1]),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     assert subroutine2Ops == [
-        TealOp(None, Op.byte, '"value"'),
-        TealOp(None, Op.store, expectedAssignments[subroutine2Slot1]),
-        TealOp(None, Op.load, expectedAssignments[subroutine2Slot1]),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.byte, '"value"'),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[subroutine2Slot1]),
+        pt.TealOp(None, pt.Op.load, expectedAssignments[subroutine2Slot1]),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     assert subroutine3Ops == [
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     assert mainOps == [
-        TealOp(None, Op.int, 7),
-        TealOp(None, Op.store, expectedAssignments[globalSlot1]),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, expectedAssignments[mainSlot1]),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.store, expectedAssignments[mainSlot2]),
-        TealOp(None, Op.load, expectedAssignments[mainSlot1]),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 7),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[globalSlot1]),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[mainSlot1]),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.store, expectedAssignments[mainSlot2]),
+        pt.TealOp(None, pt.Op.load, expectedAssignments[mainSlot1]),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
 
@@ -317,58 +317,58 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
-    globalSlot1 = ScratchSlot(requestedSlotId=8)
+    globalSlot1 = pt.ScratchSlot(requestedSlotId=8)
 
-    subroutine1Slot1 = ScratchSlot()
-    subroutine1Slot2 = ScratchSlot(requestedSlotId=5)
+    subroutine1Slot1 = pt.ScratchSlot()
+    subroutine1Slot2 = pt.ScratchSlot(requestedSlotId=5)
     subroutine1Ops = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, subroutine1Slot1),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.store, subroutine1Slot2),
-        TealOp(None, Op.load, globalSlot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot1),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot2),
+        pt.TealOp(None, pt.Op.load, globalSlot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2Slot1 = ScratchSlot(requestedSlotId=100)
+    subroutine2Slot1 = pt.ScratchSlot(requestedSlotId=100)
     subroutine2Ops = [
-        TealOp(None, Op.byte, '"value"'),
-        TealOp(None, Op.store, subroutine2Slot1),
-        TealOp(None, Op.load, subroutine2Slot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.byte, '"value"'),
+        pt.TealOp(None, pt.Op.store, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.load, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     subroutine3Ops = [
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    mainSlot1 = ScratchSlot()
-    mainSlot2 = ScratchSlot(requestedSlotId=100)
+    mainSlot1 = pt.ScratchSlot()
+    mainSlot2 = pt.ScratchSlot(requestedSlotId=100)
     mainOps = [
-        TealOp(None, Op.int, 7),
-        TealOp(None, Op.store, globalSlot1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, mainSlot1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.store, mainSlot2),
-        TealOp(None, Op.load, mainSlot1),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 7),
+        pt.TealOp(None, pt.Op.store, globalSlot1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, mainSlot1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.store, mainSlot2),
+        pt.TealOp(None, pt.Op.load, mainSlot1),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineBlocks = {
-        None: TealSimpleBlock(mainOps),
-        subroutine1: TealSimpleBlock(subroutine1Ops),
-        subroutine2: TealSimpleBlock(subroutine2Ops),
-        subroutine3: TealSimpleBlock(subroutine3Ops),
+        None: pt.TealSimpleBlock(mainOps),
+        subroutine1: pt.TealSimpleBlock(subroutine1Ops),
+        subroutine2: pt.TealSimpleBlock(subroutine2Ops),
+        subroutine3: pt.TealSimpleBlock(subroutine3Ops),
     }
 
     # mainSlot2 and subroutine2Slot1 request the same ID, 100
-    with pytest.raises(TealInternalError):
-        actual = assignScratchSlotsToSubroutines(subroutineBlocks)
+    with pytest.raises(pt.TealInternalError):
+        assignScratchSlotsToSubroutines(subroutineBlocks)
 
 
 def test_assignScratchSlotsToSubroutines_slot_used_before_assignment():
@@ -381,52 +381,52 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
-    globalSlot1 = ScratchSlot()
+    globalSlot1 = pt.ScratchSlot()
 
-    subroutine1Slot1 = ScratchSlot()
-    subroutine1Slot2 = ScratchSlot()
+    subroutine1Slot1 = pt.ScratchSlot()
+    subroutine1Slot2 = pt.ScratchSlot()
     subroutine1Ops = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, subroutine1Slot1),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.store, subroutine1Slot2),
-        TealOp(None, Op.load, globalSlot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot1),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.store, subroutine1Slot2),
+        pt.TealOp(None, pt.Op.load, globalSlot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2Slot1 = ScratchSlot()
+    subroutine2Slot1 = pt.ScratchSlot()
     subroutine2Ops = [
-        TealOp(None, Op.byte, '"value"'),
-        TealOp(None, Op.store, subroutine2Slot1),
-        TealOp(None, Op.load, subroutine2Slot1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.byte, '"value"'),
+        pt.TealOp(None, pt.Op.store, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.load, subroutine2Slot1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     subroutine3Ops = [
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    mainSlot1 = ScratchSlot()
-    mainSlot2 = ScratchSlot()
+    mainSlot1 = pt.ScratchSlot()
+    mainSlot2 = pt.ScratchSlot()
     mainOps = [
-        TealOp(None, Op.int, 7),
-        TealOp(None, Op.store, globalSlot1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.store, mainSlot2),
-        TealOp(None, Op.load, mainSlot1),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 7),
+        pt.TealOp(None, pt.Op.store, globalSlot1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.store, mainSlot2),
+        pt.TealOp(None, pt.Op.load, mainSlot1),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineBlocks = {
-        None: TealSimpleBlock(mainOps),
-        subroutine1: TealSimpleBlock(subroutine1Ops),
-        subroutine2: TealSimpleBlock(subroutine2Ops),
-        subroutine3: TealSimpleBlock(subroutine3Ops),
+        None: pt.TealSimpleBlock(mainOps),
+        subroutine1: pt.TealSimpleBlock(subroutine1Ops),
+        subroutine2: pt.TealSimpleBlock(subroutine2Ops),
+        subroutine3: pt.TealSimpleBlock(subroutine3Ops),
     }
 
-    with pytest.raises(TealInternalError):
+    with pytest.raises(pt.TealInternalError):
         assignScratchSlotsToSubroutines(subroutineBlocks)
diff --git a/pyteal/compiler/sort_test.py b/pyteal/compiler/sort_test.py
index 9889a11b4..df23c6db6 100644
--- a/pyteal/compiler/sort_test.py
+++ b/pyteal/compiler/sort_test.py
@@ -1,10 +1,10 @@
-from .. import *
+import pyteal as pt
 
 from .sort import sortBlocks
 
 
 def test_sort_single():
-    block = TealSimpleBlock([TealOp(None, Op.int, 1)])
+    block = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.addIncoming()
     block.validateTree()
 
@@ -15,14 +15,14 @@ def test_sort_single():
 
 
 def test_sort_sequence():
-    block5 = TealSimpleBlock([TealOp(None, Op.int, 5)])
-    block4 = TealSimpleBlock([TealOp(None, Op.int, 4)])
+    block5 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 5)])
+    block4 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 4)])
     block4.setNextBlock(block5)
-    block3 = TealSimpleBlock([TealOp(None, Op.int, 3)])
+    block3 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 3)])
     block3.setNextBlock(block4)
-    block2 = TealSimpleBlock([TealOp(None, Op.int, 2)])
+    block2 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 2)])
     block2.setNextBlock(block3)
-    block1 = TealSimpleBlock([TealOp(None, Op.int, 1)])
+    block1 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])
     block1.setNextBlock(block2)
     block1.addIncoming()
     block1.validateTree()
@@ -34,9 +34,9 @@ def test_sort_sequence():
 
 
 def test_sort_branch():
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
     block.addIncoming()
@@ -49,15 +49,15 @@ def test_sort_branch():
 
 
 def test_sort_multiple_branch():
-    blockTrueTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true true"')])
-    blockTrueFalse = TealSimpleBlock([TealOp(None, Op.byte, '"true false"')])
-    blockTrueBranch = TealConditionalBlock([])
+    blockTrueTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true true"')])
+    blockTrueFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true false"')])
+    blockTrueBranch = pt.TealConditionalBlock([])
     blockTrueBranch.setTrueBlock(blockTrueTrue)
     blockTrueBranch.setFalseBlock(blockTrueFalse)
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockTrueBranch)
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
     block.addIncoming()
@@ -77,12 +77,12 @@ def test_sort_multiple_branch():
 
 
 def test_sort_branch_converge():
-    blockEnd = TealSimpleBlock([TealOp(None, Op.return_)])
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockEnd = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.return_)])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockEnd)
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
     blockFalse.setNextBlock(blockEnd)
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
     block.addIncoming()
diff --git a/pyteal/compiler/subroutines_test.py b/pyteal/compiler/subroutines_test.py
index aa707d127..cb444f872 100644
--- a/pyteal/compiler/subroutines_test.py
+++ b/pyteal/compiler/subroutines_test.py
@@ -2,7 +2,7 @@
 
 import pytest
 
-from .. import *
+import pyteal as pt
 
 from .subroutines import (
     findRecursionPoints,
@@ -29,9 +29,9 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
     subroutines = {
         subroutine1: {subroutine2, subroutine3},
@@ -59,9 +59,9 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
     subroutines = {
         subroutine1: {subroutine2, subroutine3},
@@ -89,9 +89,9 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
     subroutines = {
         subroutine1: {subroutine2, subroutine3},
@@ -119,9 +119,9 @@ def sub2Impl(a1):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.bytes)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.bytes)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
     subroutines = {
         subroutine1: {subroutine2, subroutine3},
@@ -141,17 +141,17 @@ def sub3Impl(a1, a2, a3):
 
 def test_spillLocalSlotsDuringRecursion_no_subroutines():
     for version in (4, 5):
-        l1Label = LabelReference("l1")
+        l1Label = pt.LabelReference("l1")
         mainOps = [
-            TealOp(None, Op.txn, "Fee"),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bz, l1Label),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.return_),
-            TealLabel(None, l1Label),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.txn, "Fee"),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bz, l1Label),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealLabel(None, l1Label),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.return_),
         ]
 
         subroutineMapping = {None: mainOps}
@@ -165,47 +165,47 @@ def test_spillLocalSlotsDuringRecursion_no_subroutines():
         )
 
         assert mainOps == [
-            TealOp(None, Op.txn, "Fee"),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bz, l1Label),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.return_),
-            TealLabel(None, l1Label),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.txn, "Fee"),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bz, l1Label),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealLabel(None, l1Label),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.return_),
         ]
 
 
 def test_spillLocalSlotsDuringRecursion_1_subroutine_no_recursion():
     for version in (4, 5):
-        subroutine = SubroutineDefinition(lambda: None, TealType.uint64)
+        subroutine = pt.SubroutineDefinition(lambda: None, pt.TealType.uint64)
 
-        subroutineL1Label = LabelReference("l1")
+        subroutineL1Label = pt.LabelReference("l1")
         subroutineOps = [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bnz, subroutineL1Label),
-            TealOp(None, Op.err),
-            TealLabel(None, subroutineL1Label),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bnz, subroutineL1Label),
+            pt.TealOp(None, pt.Op.err),
+            pt.TealLabel(None, subroutineL1Label),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.retsub),
         ]
 
-        l1Label = LabelReference("l1")
+        l1Label = pt.LabelReference("l1")
         mainOps = [
-            TealOp(None, Op.txn, "Fee"),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bz, l1Label),
-            TealOp(None, Op.int, 100),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.return_),
-            TealLabel(None, l1Label),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.txn, "Fee"),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bz, l1Label),
+            pt.TealOp(None, pt.Op.int, 100),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealLabel(None, l1Label),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.return_),
         ]
 
         subroutineMapping = {None: mainOps, subroutine: subroutineOps}
@@ -220,27 +220,27 @@ def test_spillLocalSlotsDuringRecursion_1_subroutine_no_recursion():
 
         assert subroutineMapping == {
             None: [
-                TealOp(None, Op.txn, "Fee"),
-                TealOp(None, Op.int, 0),
-                TealOp(None, Op.eq),
-                TealOp(None, Op.bz, l1Label),
-                TealOp(None, Op.int, 100),
-                TealOp(None, Op.callsub, subroutine),
-                TealOp(None, Op.return_),
-                TealLabel(None, l1Label),
-                TealOp(None, Op.int, 0),
-                TealOp(None, Op.return_),
+                pt.TealOp(None, pt.Op.txn, "Fee"),
+                pt.TealOp(None, pt.Op.int, 0),
+                pt.TealOp(None, pt.Op.eq),
+                pt.TealOp(None, pt.Op.bz, l1Label),
+                pt.TealOp(None, pt.Op.int, 100),
+                pt.TealOp(None, pt.Op.callsub, subroutine),
+                pt.TealOp(None, pt.Op.return_),
+                pt.TealLabel(None, l1Label),
+                pt.TealOp(None, pt.Op.int, 0),
+                pt.TealOp(None, pt.Op.return_),
             ],
             subroutine: [
-                TealOp(None, Op.store, 0),
-                TealOp(None, Op.load, 0),
-                TealOp(None, Op.int, 0),
-                TealOp(None, Op.eq),
-                TealOp(None, Op.bnz, subroutineL1Label),
-                TealOp(None, Op.err),
-                TealLabel(None, subroutineL1Label),
-                TealOp(None, Op.int, 1),
-                TealOp(None, Op.retsub),
+                pt.TealOp(None, pt.Op.store, 0),
+                pt.TealOp(None, pt.Op.load, 0),
+                pt.TealOp(None, pt.Op.int, 0),
+                pt.TealOp(None, pt.Op.eq),
+                pt.TealOp(None, pt.Op.bnz, subroutineL1Label),
+                pt.TealOp(None, pt.Op.err),
+                pt.TealLabel(None, subroutineL1Label),
+                pt.TealOp(None, pt.Op.int, 1),
+                pt.TealOp(None, pt.Op.retsub),
             ],
         }
 
@@ -249,39 +249,39 @@ def test_spillLocalSlotsDuringRecursion_1_subroutine_recursion_v4():
     def sub1Impl(a1):
         return None
 
-    subroutine = SubroutineDefinition(sub1Impl, TealType.uint64)
+    subroutine = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
 
-    subroutineL1Label = LabelReference("l1")
+    subroutineL1Label = pt.LabelReference("l1")
     subroutineOps = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutineL1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutineL1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutineL1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutineL1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    l1Label = LabelReference("l1")
+    l1Label = pt.LabelReference("l1")
     mainOps = [
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 100),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.int, 100),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {None: mainOps, subroutine: subroutineOps}
@@ -294,39 +294,39 @@ def sub1Impl(a1):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.txn, "Fee"),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bz, l1Label),
-            TealOp(None, Op.int, 100),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.return_),
-            TealLabel(None, l1Label),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.txn, "Fee"),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bz, l1Label),
+            pt.TealOp(None, pt.Op.int, 100),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealLabel(None, l1Label),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.return_),
         ],
         subroutine: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bnz, subroutineL1Label),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.minus),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.dig, 1),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.pop),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.add),
-            TealOp(None, Op.retsub),
-            TealLabel(None, subroutineL1Label),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bnz, subroutineL1Label),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.minus),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.dig, 1),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.pop),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.add),
+            pt.TealOp(None, pt.Op.retsub),
+            pt.TealLabel(None, subroutineL1Label),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -335,39 +335,39 @@ def test_spillLocalSlotsDuringRecursion_1_subroutine_recursion_v5():
     def sub1Impl(a1):
         return None
 
-    subroutine = SubroutineDefinition(sub1Impl, TealType.uint64)
+    subroutine = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
 
-    subroutineL1Label = LabelReference("l1")
+    subroutineL1Label = pt.LabelReference("l1")
     subroutineOps = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutineL1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutineL1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutineL1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutineL1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    l1Label = LabelReference("l1")
+    l1Label = pt.LabelReference("l1")
     mainOps = [
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 100),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.int, 100),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {None: mainOps, subroutine: subroutineOps}
@@ -380,37 +380,37 @@ def sub1Impl(a1):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.txn, "Fee"),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bz, l1Label),
-            TealOp(None, Op.int, 100),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.return_),
-            TealLabel(None, l1Label),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.txn, "Fee"),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bz, l1Label),
+            pt.TealOp(None, pt.Op.int, 100),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealLabel(None, l1Label),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.return_),
         ],
         subroutine: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bnz, subroutineL1Label),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.minus),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.add),
-            TealOp(None, Op.retsub),
-            TealLabel(None, subroutineL1Label),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bnz, subroutineL1Label),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.minus),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.add),
+            pt.TealOp(None, pt.Op.retsub),
+            pt.TealLabel(None, subroutineL1Label),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -427,54 +427,54 @@ def sub2Impl(a1, a2):
         def sub3Impl(a1, a2, a3):
             return None
 
-        subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-        subroutine2 = SubroutineDefinition(sub1Impl, TealType.uint64)
-        subroutine3 = SubroutineDefinition(sub1Impl, TealType.none)
+        subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+        subroutine2 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+        subroutine3 = pt.SubroutineDefinition(sub1Impl, pt.TealType.none)
 
-        subroutine1L1Label = LabelReference("l1")
+        subroutine1L1Label = pt.LabelReference("l1")
         subroutine1Ops = [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bnz, subroutine1L1Label),
-            TealOp(None, Op.err),
-            TealLabel(None, subroutine1L1Label),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.callsub, subroutine3),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bnz, subroutine1L1Label),
+            pt.TealOp(None, pt.Op.err),
+            pt.TealLabel(None, subroutine1L1Label),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.callsub, subroutine3),
+            pt.TealOp(None, pt.Op.retsub),
         ]
 
-        subroutine2L1Label = LabelReference("l1")
+        subroutine2L1Label = pt.LabelReference("l1")
         subroutine2Ops = [
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.load, 1),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bnz, subroutine2L1Label),
-            TealOp(None, Op.err),
-            TealLabel(None, subroutine2L1Label),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.load, 1),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+            pt.TealOp(None, pt.Op.err),
+            pt.TealLabel(None, subroutine2L1Label),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.retsub),
         ]
 
         subroutine3Ops = [
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.retsub),
         ]
 
-        l1Label = LabelReference("l1")
+        l1Label = pt.LabelReference("l1")
         mainOps = [
-            TealOp(None, Op.txn, "Fee"),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bz, l1Label),
-            TealOp(None, Op.int, 100),
-            TealOp(None, Op.callsub, subroutine1),
-            TealOp(None, Op.return_),
-            TealLabel(None, l1Label),
-            TealOp(None, Op.int, 101),
-            TealOp(None, Op.callsub, subroutine2),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.txn, "Fee"),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bz, l1Label),
+            pt.TealOp(None, pt.Op.int, 100),
+            pt.TealOp(None, pt.Op.callsub, subroutine1),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealLabel(None, l1Label),
+            pt.TealOp(None, pt.Op.int, 101),
+            pt.TealOp(None, pt.Op.callsub, subroutine2),
+            pt.TealOp(None, pt.Op.return_),
         ]
 
         subroutineMapping = {
@@ -498,43 +498,43 @@ def sub3Impl(a1, a2, a3):
 
         assert subroutineMapping == {
             None: [
-                TealOp(None, Op.txn, "Fee"),
-                TealOp(None, Op.int, 0),
-                TealOp(None, Op.eq),
-                TealOp(None, Op.bz, l1Label),
-                TealOp(None, Op.int, 100),
-                TealOp(None, Op.callsub, subroutine1),
-                TealOp(None, Op.return_),
-                TealLabel(None, l1Label),
-                TealOp(None, Op.int, 101),
-                TealOp(None, Op.callsub, subroutine2),
-                TealOp(None, Op.return_),
+                pt.TealOp(None, pt.Op.txn, "Fee"),
+                pt.TealOp(None, pt.Op.int, 0),
+                pt.TealOp(None, pt.Op.eq),
+                pt.TealOp(None, pt.Op.bz, l1Label),
+                pt.TealOp(None, pt.Op.int, 100),
+                pt.TealOp(None, pt.Op.callsub, subroutine1),
+                pt.TealOp(None, pt.Op.return_),
+                pt.TealLabel(None, l1Label),
+                pt.TealOp(None, pt.Op.int, 101),
+                pt.TealOp(None, pt.Op.callsub, subroutine2),
+                pt.TealOp(None, pt.Op.return_),
             ],
             subroutine1: [
-                TealOp(None, Op.store, 0),
-                TealOp(None, Op.load, 0),
-                TealOp(None, Op.int, 0),
-                TealOp(None, Op.eq),
-                TealOp(None, Op.bnz, subroutine1L1Label),
-                TealOp(None, Op.err),
-                TealLabel(None, subroutine1L1Label),
-                TealOp(None, Op.int, 1),
-                TealOp(None, Op.callsub, subroutine3),
-                TealOp(None, Op.retsub),
+                pt.TealOp(None, pt.Op.store, 0),
+                pt.TealOp(None, pt.Op.load, 0),
+                pt.TealOp(None, pt.Op.int, 0),
+                pt.TealOp(None, pt.Op.eq),
+                pt.TealOp(None, pt.Op.bnz, subroutine1L1Label),
+                pt.TealOp(None, pt.Op.err),
+                pt.TealLabel(None, subroutine1L1Label),
+                pt.TealOp(None, pt.Op.int, 1),
+                pt.TealOp(None, pt.Op.callsub, subroutine3),
+                pt.TealOp(None, pt.Op.retsub),
             ],
             subroutine2: [
-                TealOp(None, Op.store, 1),
-                TealOp(None, Op.load, 1),
-                TealOp(None, Op.int, 0),
-                TealOp(None, Op.eq),
-                TealOp(None, Op.bnz, subroutine2L1Label),
-                TealOp(None, Op.err),
-                TealLabel(None, subroutine2L1Label),
-                TealOp(None, Op.int, 1),
-                TealOp(None, Op.retsub),
+                pt.TealOp(None, pt.Op.store, 1),
+                pt.TealOp(None, pt.Op.load, 1),
+                pt.TealOp(None, pt.Op.int, 0),
+                pt.TealOp(None, pt.Op.eq),
+                pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+                pt.TealOp(None, pt.Op.err),
+                pt.TealLabel(None, subroutine2L1Label),
+                pt.TealOp(None, pt.Op.int, 1),
+                pt.TealOp(None, pt.Op.retsub),
             ],
             subroutine3: [
-                TealOp(None, Op.retsub),
+                pt.TealOp(None, pt.Op.retsub),
             ],
         }
 
@@ -549,69 +549,69 @@ def sub2Impl(a1, a2):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine3 = SubroutineDefinition(sub1Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine3 = pt.SubroutineDefinition(sub1Impl, pt.TealType.none)
 
-    subroutine1L1Label = LabelReference("l1")
+    subroutine1L1Label = pt.LabelReference("l1")
     subroutine1Ops = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine1L1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine1L1Label),
-        TealOp(None, Op.load, 255),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.load, 255),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2L1Label = LabelReference("l1")
+    subroutine2L1Label = pt.LabelReference("l1")
     subroutine2Ops = [
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.load, 1),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine2L1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine2L1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.load, 1),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     subroutine3Ops = [
-        TealOp(None, Op.callsub, subroutine3),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.callsub, subroutine3),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    l1Label = LabelReference("l1")
+    l1Label = pt.LabelReference("l1")
     mainOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, 255),
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 100),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 101),
-        TealOp(None, Op.callsub, subroutine2),
-        TealOp(None, Op.return_),
-        TealOp(None, Op.callsub, subroutine3),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, 255),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.int, 100),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 101),
+        pt.TealOp(None, pt.Op.callsub, subroutine2),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealOp(None, pt.Op.callsub, subroutine3),
     ]
 
     subroutineMapping = {
@@ -633,64 +633,64 @@ def sub3Impl(a1, a2, a3):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.store, 255),
-            TealOp(None, Op.txn, "Fee"),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bz, l1Label),
-            TealOp(None, Op.int, 100),
-            TealOp(None, Op.callsub, subroutine1),
-            TealOp(None, Op.return_),
-            TealLabel(None, l1Label),
-            TealOp(None, Op.int, 101),
-            TealOp(None, Op.callsub, subroutine2),
-            TealOp(None, Op.return_),
-            TealOp(None, Op.callsub, subroutine3),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.store, 255),
+            pt.TealOp(None, pt.Op.txn, "Fee"),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bz, l1Label),
+            pt.TealOp(None, pt.Op.int, 100),
+            pt.TealOp(None, pt.Op.callsub, subroutine1),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealLabel(None, l1Label),
+            pt.TealOp(None, pt.Op.int, 101),
+            pt.TealOp(None, pt.Op.callsub, subroutine2),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealOp(None, pt.Op.callsub, subroutine3),
         ],
         subroutine1: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bnz, subroutine1L1Label),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.minus),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.dig, 1),
-            TealOp(None, Op.callsub, subroutine1),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.pop),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.add),
-            TealOp(None, Op.retsub),
-            TealLabel(None, subroutine1L1Label),
-            TealOp(None, Op.load, 255),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bnz, subroutine1L1Label),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.minus),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.dig, 1),
+            pt.TealOp(None, pt.Op.callsub, subroutine1),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.pop),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.add),
+            pt.TealOp(None, pt.Op.retsub),
+            pt.TealLabel(None, subroutine1L1Label),
+            pt.TealOp(None, pt.Op.load, 255),
+            pt.TealOp(None, pt.Op.retsub),
         ],
         subroutine2: [
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.load, 1),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bnz, subroutine2L1Label),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.minus),
-            TealOp(None, Op.callsub, subroutine1),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.add),
-            TealOp(None, Op.retsub),
-            TealLabel(None, subroutine2L1Label),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.load, 1),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.minus),
+            pt.TealOp(None, pt.Op.callsub, subroutine1),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.add),
+            pt.TealOp(None, pt.Op.retsub),
+            pt.TealLabel(None, subroutine2L1Label),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.retsub),
         ],
         subroutine3: [
-            TealOp(None, Op.callsub, subroutine3),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.callsub, subroutine3),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -705,69 +705,69 @@ def sub2Impl(a1, a2):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine3 = SubroutineDefinition(sub1Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine3 = pt.SubroutineDefinition(sub1Impl, pt.TealType.none)
 
-    subroutine1L1Label = LabelReference("l1")
+    subroutine1L1Label = pt.LabelReference("l1")
     subroutine1Ops = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine1L1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine1L1Label),
-        TealOp(None, Op.load, 255),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.load, 255),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2L1Label = LabelReference("l1")
+    subroutine2L1Label = pt.LabelReference("l1")
     subroutine2Ops = [
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.load, 1),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine2L1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine2L1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.load, 1),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     subroutine3Ops = [
-        TealOp(None, Op.callsub, subroutine3),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.callsub, subroutine3),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    l1Label = LabelReference("l1")
+    l1Label = pt.LabelReference("l1")
     mainOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, 255),
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 100),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 101),
-        TealOp(None, Op.callsub, subroutine2),
-        TealOp(None, Op.return_),
-        TealOp(None, Op.callsub, subroutine3),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, 255),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.int, 100),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 101),
+        pt.TealOp(None, pt.Op.callsub, subroutine2),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealOp(None, pt.Op.callsub, subroutine3),
     ]
 
     subroutineMapping = {
@@ -789,62 +789,62 @@ def sub3Impl(a1, a2, a3):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.store, 255),
-            TealOp(None, Op.txn, "Fee"),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bz, l1Label),
-            TealOp(None, Op.int, 100),
-            TealOp(None, Op.callsub, subroutine1),
-            TealOp(None, Op.return_),
-            TealLabel(None, l1Label),
-            TealOp(None, Op.int, 101),
-            TealOp(None, Op.callsub, subroutine2),
-            TealOp(None, Op.return_),
-            TealOp(None, Op.callsub, subroutine3),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.store, 255),
+            pt.TealOp(None, pt.Op.txn, "Fee"),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bz, l1Label),
+            pt.TealOp(None, pt.Op.int, 100),
+            pt.TealOp(None, pt.Op.callsub, subroutine1),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealLabel(None, l1Label),
+            pt.TealOp(None, pt.Op.int, 101),
+            pt.TealOp(None, pt.Op.callsub, subroutine2),
+            pt.TealOp(None, pt.Op.return_),
+            pt.TealOp(None, pt.Op.callsub, subroutine3),
         ],
         subroutine1: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bnz, subroutine1L1Label),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.minus),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.callsub, subroutine1),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.add),
-            TealOp(None, Op.retsub),
-            TealLabel(None, subroutine1L1Label),
-            TealOp(None, Op.load, 255),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bnz, subroutine1L1Label),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.minus),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.callsub, subroutine1),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.add),
+            pt.TealOp(None, pt.Op.retsub),
+            pt.TealLabel(None, subroutine1L1Label),
+            pt.TealOp(None, pt.Op.load, 255),
+            pt.TealOp(None, pt.Op.retsub),
         ],
         subroutine2: [
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.load, 1),
-            TealOp(None, Op.int, 0),
-            TealOp(None, Op.eq),
-            TealOp(None, Op.bnz, subroutine2L1Label),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.minus),
-            TealOp(None, Op.callsub, subroutine1),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.add),
-            TealOp(None, Op.retsub),
-            TealLabel(None, subroutine2L1Label),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.load, 1),
+            pt.TealOp(None, pt.Op.int, 0),
+            pt.TealOp(None, pt.Op.eq),
+            pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.minus),
+            pt.TealOp(None, pt.Op.callsub, subroutine1),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.add),
+            pt.TealOp(None, pt.Op.retsub),
+            pt.TealLabel(None, subroutine2L1Label),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.retsub),
         ],
         subroutine3: [
-            TealOp(None, Op.callsub, subroutine3),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.callsub, subroutine3),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -853,26 +853,26 @@ def test_spillLocalSlotsDuringRecursion_recursive_many_args_no_return_v4():
     def subImpl(a1, a2, a3):
         return None
 
-    subroutine = SubroutineDefinition(subImpl, TealType.none)
+    subroutine = pt.SubroutineDefinition(subImpl, pt.TealType.none)
 
     subroutineOps = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.store, 2),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.store, 2),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     mainOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {
@@ -890,34 +890,34 @@ def subImpl(a1, a2, a3):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.return_),
         ],
         subroutine: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.load, 1),
-            TealOp(None, Op.load, 2),
-            TealOp(None, Op.dig, 5),
-            TealOp(None, Op.dig, 5),
-            TealOp(None, Op.dig, 5),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.pop),
-            TealOp(None, Op.pop),
-            TealOp(None, Op.pop),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.load, 1),
+            pt.TealOp(None, pt.Op.load, 2),
+            pt.TealOp(None, pt.Op.dig, 5),
+            pt.TealOp(None, pt.Op.dig, 5),
+            pt.TealOp(None, pt.Op.dig, 5),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.pop),
+            pt.TealOp(None, pt.Op.pop),
+            pt.TealOp(None, pt.Op.pop),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -926,26 +926,26 @@ def test_spillLocalSlotsDuringRecursion_recursive_many_args_no_return_v5():
     def subImpl(a1, a2, a3):
         return None
 
-    subroutine = SubroutineDefinition(subImpl, TealType.none)
+    subroutine = pt.SubroutineDefinition(subImpl, pt.TealType.none)
 
     subroutineOps = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.store, 2),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.store, 2),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     mainOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {
@@ -963,31 +963,31 @@ def subImpl(a1, a2, a3):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.return_),
         ],
         subroutine: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.load, 1),
-            TealOp(None, Op.load, 2),
-            TealOp(None, Op.uncover, 5),
-            TealOp(None, Op.uncover, 5),
-            TealOp(None, Op.uncover, 5),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.load, 1),
+            pt.TealOp(None, pt.Op.load, 2),
+            pt.TealOp(None, pt.Op.uncover, 5),
+            pt.TealOp(None, pt.Op.uncover, 5),
+            pt.TealOp(None, pt.Op.uncover, 5),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -996,25 +996,25 @@ def test_spillLocalSlotsDuringRecursion_recursive_many_args_return_v4():
     def subImpl(a1, a2, a3):
         return None
 
-    subroutine = SubroutineDefinition(subImpl, TealType.uint64)
+    subroutine = pt.SubroutineDefinition(subImpl, pt.TealType.uint64)
 
     subroutineOps = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.store, 2),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.store, 2),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     mainOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {
@@ -1032,39 +1032,39 @@ def subImpl(a1, a2, a3):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.return_),
         ],
         subroutine: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.load, 1),
-            TealOp(None, Op.load, 2),
-            TealOp(None, Op.dig, 5),
-            TealOp(None, Op.dig, 5),
-            TealOp(None, Op.dig, 5),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.pop),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.pop),
-            TealOp(None, Op.swap),
-            TealOp(None, Op.pop),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.load, 1),
+            pt.TealOp(None, pt.Op.load, 2),
+            pt.TealOp(None, pt.Op.dig, 5),
+            pt.TealOp(None, pt.Op.dig, 5),
+            pt.TealOp(None, pt.Op.dig, 5),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.pop),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.pop),
+            pt.TealOp(None, pt.Op.swap),
+            pt.TealOp(None, pt.Op.pop),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -1073,25 +1073,25 @@ def test_spillLocalSlotsDuringRecursion_recursive_many_args_return_v5():
     def subImpl(a1, a2, a3):
         return None
 
-    subroutine = SubroutineDefinition(subImpl, TealType.uint64)
+    subroutine = pt.SubroutineDefinition(subImpl, pt.TealType.uint64)
 
     subroutineOps = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.store, 2),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.store, 2),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     mainOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {
@@ -1109,31 +1109,31 @@ def subImpl(a1, a2, a3):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.return_),
         ],
         subroutine: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.load, 1),
-            TealOp(None, Op.load, 2),
-            TealOp(None, Op.uncover, 5),
-            TealOp(None, Op.uncover, 5),
-            TealOp(None, Op.uncover, 5),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.cover, 3),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.load, 1),
+            pt.TealOp(None, pt.Op.load, 2),
+            pt.TealOp(None, pt.Op.uncover, 5),
+            pt.TealOp(None, pt.Op.uncover, 5),
+            pt.TealOp(None, pt.Op.uncover, 5),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.cover, 3),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -1142,25 +1142,25 @@ def test_spillLocalSlotsDuringRecursion_recursive_more_args_than_slots_v5():
     def subImpl(a1, a2, a3):
         return None
 
-    subroutine = SubroutineDefinition(subImpl, TealType.uint64)
+    subroutine = pt.SubroutineDefinition(subImpl, pt.TealType.uint64)
 
     subroutineOps = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     mainOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {
@@ -1178,28 +1178,28 @@ def subImpl(a1, a2, a3):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.return_),
         ],
         subroutine: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.pop),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.cover, 3),
-            TealOp(None, Op.load, 1),
-            TealOp(None, Op.cover, 3),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.cover, 2),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.pop),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.cover, 3),
+            pt.TealOp(None, pt.Op.load, 1),
+            pt.TealOp(None, pt.Op.cover, 3),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.cover, 2),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -1208,27 +1208,27 @@ def test_spillLocalSlotsDuringRecursion_recursive_more_slots_than_args_v5():
     def subImpl(a1, a2, a3):
         return None
 
-    subroutine = SubroutineDefinition(subImpl, TealType.uint64)
+    subroutine = pt.SubroutineDefinition(subImpl, pt.TealType.uint64)
 
     subroutineOps = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.store, 2),
-        TealOp(None, Op.int, 10),
-        TealOp(None, Op.store, 3),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.store, 2),
+        pt.TealOp(None, pt.Op.int, 10),
+        pt.TealOp(None, pt.Op.store, 3),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     mainOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.int, 2),
-        TealOp(None, Op.int, 3),
-        TealOp(None, Op.callsub, subroutine),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.int, 2),
+        pt.TealOp(None, pt.Op.int, 3),
+        pt.TealOp(None, pt.Op.callsub, subroutine),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {
@@ -1246,35 +1246,35 @@ def subImpl(a1, a2, a3):
 
     assert subroutineMapping == {
         None: [
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.return_),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.return_),
         ],
         subroutine: [
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.int, 10),
-            TealOp(None, Op.store, 3),
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.load, 0),
-            TealOp(None, Op.load, 1),
-            TealOp(None, Op.load, 2),
-            TealOp(None, Op.load, 3),
-            TealOp(None, Op.uncover, 6),
-            TealOp(None, Op.uncover, 6),
-            TealOp(None, Op.uncover, 6),
-            TealOp(None, Op.callsub, subroutine),
-            TealOp(None, Op.cover, 4),
-            TealOp(None, Op.store, 3),
-            TealOp(None, Op.store, 2),
-            TealOp(None, Op.store, 1),
-            TealOp(None, Op.store, 0),
-            TealOp(None, Op.retsub),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.int, 10),
+            pt.TealOp(None, pt.Op.store, 3),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.load, 0),
+            pt.TealOp(None, pt.Op.load, 1),
+            pt.TealOp(None, pt.Op.load, 2),
+            pt.TealOp(None, pt.Op.load, 3),
+            pt.TealOp(None, pt.Op.uncover, 6),
+            pt.TealOp(None, pt.Op.uncover, 6),
+            pt.TealOp(None, pt.Op.uncover, 6),
+            pt.TealOp(None, pt.Op.callsub, subroutine),
+            pt.TealOp(None, pt.Op.cover, 4),
+            pt.TealOp(None, pt.Op.store, 3),
+            pt.TealOp(None, pt.Op.store, 2),
+            pt.TealOp(None, pt.Op.store, 1),
+            pt.TealOp(None, pt.Op.store, 0),
+            pt.TealOp(None, pt.Op.retsub),
         ],
     }
 
@@ -1285,60 +1285,60 @@ def test_spillLocalSlotsDuringRecursion_recursive_with_scratchvar():
     def sub1Impl(a1):
         return None
 
-    def sub2Impl(a1, a2: ScratchVar):
+    def sub2Impl(a1, a2: pt.ScratchVar):
         return None
 
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.uint64)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.uint64)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
-    subroutine1L1Label = LabelReference("l1")
+    subroutine1L1Label = pt.LabelReference("l1")
     subroutine1Ops = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine1L1Label),
-        TealOp(None, Op.err),
-        TealLabel(None, subroutine1L1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.callsub, subroutine3),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.err),
+        pt.TealLabel(None, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.callsub, subroutine3),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2L1Label = LabelReference("l1")
+    subroutine2L1Label = pt.LabelReference("l1")
     subroutine2Ops = [
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.load, 1),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine2L1Label),
-        TealOp(None, Op.err),
-        TealLabel(None, subroutine2L1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.load, 1),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.err),
+        pt.TealLabel(None, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     subroutine3Ops = [
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    l1Label = LabelReference("l1")
+    l1Label = pt.LabelReference("l1")
     mainOps = [
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 100),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 101),
-        TealOp(None, Op.callsub, subroutine2),
-        TealOp(None, Op.return_),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.int, 100),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 101),
+        pt.TealOp(None, pt.Op.callsub, subroutine2),
+        pt.TealOp(None, pt.Op.return_),
     ]
 
     subroutineMapping = {
@@ -1356,7 +1356,7 @@ def sub3Impl(a1, a2, a3):
 
     localSlots = {None: set(), subroutine1: {0}, subroutine2: {1}, subroutine3: {}}
 
-    with pytest.raises(TealInputError) as tie:
+    with pytest.raises(pt.TealInputError) as tie:
         spillLocalSlotsDuringRecursion(
             5, subroutineMapping, subroutineGraph, localSlots
         )
@@ -1377,75 +1377,75 @@ def sub2Impl(a1, a2):
     def sub3Impl(a1, a2, a3):
         return None
 
-    subroutine1 = SubroutineDefinition(sub1Impl, TealType.uint64)
-    subroutine2 = SubroutineDefinition(sub2Impl, TealType.uint64)
-    subroutine3 = SubroutineDefinition(sub3Impl, TealType.none)
+    subroutine1 = pt.SubroutineDefinition(sub1Impl, pt.TealType.uint64)
+    subroutine2 = pt.SubroutineDefinition(sub2Impl, pt.TealType.uint64)
+    subroutine3 = pt.SubroutineDefinition(sub3Impl, pt.TealType.none)
 
-    subroutine1L1Label = LabelReference("l1")
+    subroutine1L1Label = pt.LabelReference("l1")
     subroutine1Ops = [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine1L1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.dig, 1),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.swap),
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.swap),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine1L1Label),
-        TealOp(None, Op.load, 255),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.dig, 1),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.swap),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.swap),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.load, 255),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    subroutine2L1Label = LabelReference("l1")
+    subroutine2L1Label = pt.LabelReference("l1")
     subroutine2Ops = [
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.load, 1),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine2L1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine2L1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.load, 1),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     subroutine3Ops = [
-        TealOp(None, Op.callsub, subroutine3),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.callsub, subroutine3),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
-    l1Label = LabelReference("l1")
+    l1Label = pt.LabelReference("l1")
     mainOps = [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, 255),
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 100),
-        TealOp(None, Op.callsub, subroutine1),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 101),
-        TealOp(None, Op.callsub, subroutine2),
-        TealOp(None, Op.return_),
-        TealOp(None, Op.callsub, subroutine3),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, 255),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.int, 100),
+        pt.TealOp(None, pt.Op.callsub, subroutine1),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 101),
+        pt.TealOp(None, pt.Op.callsub, subroutine2),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealOp(None, pt.Op.callsub, subroutine3),
     ]
 
     subroutineMapping = {
@@ -1464,65 +1464,65 @@ def sub3Impl(a1, a2, a3):
     assert actual == expected
 
     assert mainOps == [
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.store, 255),
-        TealOp(None, Op.txn, "Fee"),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bz, l1Label),
-        TealOp(None, Op.int, 100),
-        TealOp(None, Op.callsub, expected[subroutine1]),
-        TealOp(None, Op.return_),
-        TealLabel(None, l1Label),
-        TealOp(None, Op.int, 101),
-        TealOp(None, Op.callsub, expected[subroutine2]),
-        TealOp(None, Op.return_),
-        TealOp(None, Op.callsub, expected[subroutine3]),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.store, 255),
+        pt.TealOp(None, pt.Op.txn, "Fee"),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bz, l1Label),
+        pt.TealOp(None, pt.Op.int, 100),
+        pt.TealOp(None, pt.Op.callsub, expected[subroutine1]),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealLabel(None, l1Label),
+        pt.TealOp(None, pt.Op.int, 101),
+        pt.TealOp(None, pt.Op.callsub, expected[subroutine2]),
+        pt.TealOp(None, pt.Op.return_),
+        pt.TealOp(None, pt.Op.callsub, expected[subroutine3]),
     ]
 
     assert subroutine1Ops == [
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine1L1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.dig, 1),
-        TealOp(None, Op.callsub, expected[subroutine1]),
-        TealOp(None, Op.swap),
-        TealOp(None, Op.store, 0),
-        TealOp(None, Op.swap),
-        TealOp(None, Op.pop),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine1L1Label),
-        TealOp(None, Op.load, 255),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.dig, 1),
+        pt.TealOp(None, pt.Op.callsub, expected[subroutine1]),
+        pt.TealOp(None, pt.Op.swap),
+        pt.TealOp(None, pt.Op.store, 0),
+        pt.TealOp(None, pt.Op.swap),
+        pt.TealOp(None, pt.Op.pop),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine1L1Label),
+        pt.TealOp(None, pt.Op.load, 255),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     assert subroutine2Ops == [
-        TealOp(None, Op.store, 1),
-        TealOp(None, Op.load, 1),
-        TealOp(None, Op.int, 0),
-        TealOp(None, Op.eq),
-        TealOp(None, Op.bnz, subroutine2L1Label),
-        TealOp(None, Op.load, 0),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.minus),
-        TealOp(None, Op.callsub, expected[subroutine1]),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.add),
-        TealOp(None, Op.retsub),
-        TealLabel(None, subroutine2L1Label),
-        TealOp(None, Op.int, 1),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.store, 1),
+        pt.TealOp(None, pt.Op.load, 1),
+        pt.TealOp(None, pt.Op.int, 0),
+        pt.TealOp(None, pt.Op.eq),
+        pt.TealOp(None, pt.Op.bnz, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.load, 0),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.minus),
+        pt.TealOp(None, pt.Op.callsub, expected[subroutine1]),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.add),
+        pt.TealOp(None, pt.Op.retsub),
+        pt.TealLabel(None, subroutine2L1Label),
+        pt.TealOp(None, pt.Op.int, 1),
+        pt.TealOp(None, pt.Op.retsub),
     ]
 
     assert subroutine3Ops == [
-        TealOp(None, Op.callsub, expected[subroutine3]),
-        TealOp(None, Op.retsub),
+        pt.TealOp(None, pt.Op.callsub, expected[subroutine3]),
+        pt.TealOp(None, pt.Op.retsub),
     ]
diff --git a/pyteal/ir/tealblock_test.py b/pyteal/ir/tealblock_test.py
index 511ed26a7..b301a269b 100644
--- a/pyteal/ir/tealblock_test.py
+++ b/pyteal/ir/tealblock_test.py
@@ -1,129 +1,126 @@
-from .. import *
+import pyteal as pt
 
-# this is not necessary but mypy complains if it's not included
-from .. import CompileOptions
-
-options = CompileOptions()
+options = pt.CompileOptions()
 
 
 def test_from_op_no_args():
-    op = TealOp(None, Op.int, 1)
+    op = pt.TealOp(None, pt.Op.int, 1)
 
-    expected = TealSimpleBlock([op])
+    expected = pt.TealSimpleBlock([op])
 
-    actual, _ = TealBlock.FromOp(options, op)
+    actual, _ = pt.TealBlock.FromOp(options, op)
 
     assert actual == expected
 
 
 def test_from_op_1_arg():
-    op = TealOp(None, Op.pop)
-    arg_1 = Bytes("message")
+    op = pt.TealOp(None, pt.Op.pop)
+    arg_1 = pt.Bytes("message")
 
-    expected = TealSimpleBlock([TealOp(arg_1, Op.byte, '"message"'), op])
+    expected = pt.TealSimpleBlock([pt.TealOp(arg_1, pt.Op.byte, '"message"'), op])
 
-    actual, _ = TealBlock.FromOp(options, op, arg_1)
+    actual, _ = pt.TealBlock.FromOp(options, op, arg_1)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
     actual.validateTree()
 
     assert actual == expected
 
 
 def test_from_op_2_args():
-    op = TealOp(None, Op.app_global_put)
-    arg_1 = Bytes("key")
-    arg_2 = Int(5)
+    op = pt.TealOp(None, pt.Op.app_global_put)
+    arg_1 = pt.Bytes("key")
+    arg_2 = pt.Int(5)
 
-    expected = TealSimpleBlock(
-        [TealOp(arg_1, Op.byte, '"key"'), TealOp(arg_2, Op.int, 5), op]
+    expected = pt.TealSimpleBlock(
+        [pt.TealOp(arg_1, pt.Op.byte, '"key"'), pt.TealOp(arg_2, pt.Op.int, 5), op]
     )
 
-    actual, _ = TealBlock.FromOp(options, op, arg_1, arg_2)
+    actual, _ = pt.TealBlock.FromOp(options, op, arg_1, arg_2)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
     actual.validateTree()
 
     assert actual == expected
 
 
 def test_from_op_3_args():
-    op = TealOp(None, Op.app_local_put)
-    arg_1 = Int(0)
-    arg_2 = Bytes("key")
-    arg_3 = Int(1)
-    arg_4 = Int(2)
+    op = pt.TealOp(None, pt.Op.app_local_put)
+    arg_1 = pt.Int(0)
+    arg_2 = pt.Bytes("key")
+    arg_3 = pt.Int(1)
+    arg_4 = pt.Int(2)
     arg_3_plus_4 = arg_3 + arg_4
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(arg_1, Op.int, 0),
-            TealOp(arg_2, Op.byte, '"key"'),
-            TealOp(arg_3, Op.int, 1),
-            TealOp(arg_4, Op.int, 2),
-            TealOp(arg_3_plus_4, Op.add),
+            pt.TealOp(arg_1, pt.Op.int, 0),
+            pt.TealOp(arg_2, pt.Op.byte, '"key"'),
+            pt.TealOp(arg_3, pt.Op.int, 1),
+            pt.TealOp(arg_4, pt.Op.int, 2),
+            pt.TealOp(arg_3_plus_4, pt.Op.add),
             op,
         ]
     )
 
-    actual, _ = TealBlock.FromOp(options, op, arg_1, arg_2, arg_3_plus_4)
+    actual, _ = pt.TealBlock.FromOp(options, op, arg_1, arg_2, arg_3_plus_4)
     actual.addIncoming()
-    actual = TealBlock.NormalizeBlocks(actual)
+    actual = pt.TealBlock.NormalizeBlocks(actual)
     actual.validateTree()
 
     assert actual == expected
 
 
 def test_iterate_single():
-    block = TealSimpleBlock([TealOp(None, Op.int, 1)])
+    block = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])
 
-    blocks = list(TealBlock.Iterate(block))
+    blocks = list(pt.TealBlock.Iterate(block))
 
     assert blocks == [block]
 
 
 def test_iterate_sequence():
-    block5 = TealSimpleBlock([TealOp(None, Op.int, 5)])
-    block4 = TealSimpleBlock([TealOp(None, Op.int, 4)])
+    block5 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 5)])
+    block4 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 4)])
     block4.setNextBlock(block5)
-    block3 = TealSimpleBlock([TealOp(None, Op.int, 3)])
+    block3 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 3)])
     block3.setNextBlock(block4)
-    block2 = TealSimpleBlock([TealOp(None, Op.int, 2)])
+    block2 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 2)])
     block2.setNextBlock(block3)
-    block1 = TealSimpleBlock([TealOp(None, Op.int, 1)])
+    block1 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])
     block1.setNextBlock(block2)
 
-    blocks = list(TealBlock.Iterate(block1))
+    blocks = list(pt.TealBlock.Iterate(block1))
 
     assert blocks == [block1, block2, block3, block4, block5]
 
 
 def test_iterate_branch():
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
 
-    blocks = list(TealBlock.Iterate(block))
+    blocks = list(pt.TealBlock.Iterate(block))
 
     assert blocks == [block, blockTrue, blockFalse]
 
 
 def test_iterate_multiple_branch():
-    blockTrueTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true true"')])
-    blockTrueFalse = TealSimpleBlock([TealOp(None, Op.byte, '"true false"')])
-    blockTrueBranch = TealConditionalBlock([])
+    blockTrueTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true true"')])
+    blockTrueFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true false"')])
+    blockTrueBranch = pt.TealConditionalBlock([])
     blockTrueBranch.setTrueBlock(blockTrueTrue)
     blockTrueBranch.setFalseBlock(blockTrueFalse)
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockTrueBranch)
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
 
-    blocks = list(TealBlock.Iterate(block))
+    blocks = list(pt.TealBlock.Iterate(block))
 
     assert blocks == [
         block,
@@ -136,115 +133,115 @@ def test_iterate_multiple_branch():
 
 
 def test_iterate_branch_converge():
-    blockEnd = TealSimpleBlock([TealOp(None, Op.return_)])
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockEnd = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.return_)])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockEnd)
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
     blockFalse.setNextBlock(blockEnd)
-    block = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    block = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     block.setTrueBlock(blockTrue)
     block.setFalseBlock(blockFalse)
 
-    blocks = list(TealBlock.Iterate(block))
+    blocks = list(pt.TealBlock.Iterate(block))
 
     assert blocks == [block, blockTrue, blockFalse, blockEnd]
 
 
 def test_normalize_single():
-    original = TealSimpleBlock([TealOp(None, Op.int, 1)])
+    original = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])
 
-    expected = TealSimpleBlock([TealOp(None, Op.int, 1)])
+    expected = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])
 
     original.addIncoming()
-    actual = TealBlock.NormalizeBlocks(original)
+    actual = pt.TealBlock.NormalizeBlocks(original)
     actual.validateTree()
 
     assert actual == expected
 
 
 def test_normalize_sequence():
-    block6 = TealSimpleBlock([])
-    block5 = TealSimpleBlock([TealOp(None, Op.int, 5)])
+    block6 = pt.TealSimpleBlock([])
+    block5 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 5)])
     block5.setNextBlock(block6)
-    block4 = TealSimpleBlock([TealOp(None, Op.int, 4)])
+    block4 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 4)])
     block4.setNextBlock(block5)
-    block3 = TealSimpleBlock([TealOp(None, Op.int, 3)])
+    block3 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 3)])
     block3.setNextBlock(block4)
-    block2 = TealSimpleBlock([TealOp(None, Op.int, 2)])
+    block2 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 2)])
     block2.setNextBlock(block3)
-    block1 = TealSimpleBlock([TealOp(None, Op.int, 1)])
+    block1 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])
     block1.setNextBlock(block2)
 
-    expected = TealSimpleBlock(
+    expected = pt.TealSimpleBlock(
         [
-            TealOp(None, Op.int, 1),
-            TealOp(None, Op.int, 2),
-            TealOp(None, Op.int, 3),
-            TealOp(None, Op.int, 4),
-            TealOp(None, Op.int, 5),
+            pt.TealOp(None, pt.Op.int, 1),
+            pt.TealOp(None, pt.Op.int, 2),
+            pt.TealOp(None, pt.Op.int, 3),
+            pt.TealOp(None, pt.Op.int, 4),
+            pt.TealOp(None, pt.Op.int, 5),
         ]
     )
 
     block1.addIncoming()
-    actual = TealBlock.NormalizeBlocks(block1)
+    actual = pt.TealBlock.NormalizeBlocks(block1)
     actual.validateTree()
 
     assert actual == expected
 
 
 def test_normalize_branch():
-    blockTrueNext = TealSimpleBlock([TealOp(None, Op.int, 4)])
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockTrueNext = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 4)])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockTrueNext)
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
-    blockBranch = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
+    blockBranch = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     blockBranch.setTrueBlock(blockTrue)
     blockBranch.setFalseBlock(blockFalse)
-    original = TealSimpleBlock([])
+    original = pt.TealSimpleBlock([])
     original.setNextBlock(blockBranch)
 
-    expectedTrue = TealSimpleBlock(
-        [TealOp(None, Op.byte, '"true"'), TealOp(None, Op.int, 4)]
+    expectedTrue = pt.TealSimpleBlock(
+        [pt.TealOp(None, pt.Op.byte, '"true"'), pt.TealOp(None, pt.Op.int, 4)]
     )
-    expectedFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
-    expected = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    expectedFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
+    expected = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     expected.setTrueBlock(expectedTrue)
     expected.setFalseBlock(expectedFalse)
 
     original.addIncoming()
-    actual = TealBlock.NormalizeBlocks(original)
+    actual = pt.TealBlock.NormalizeBlocks(original)
     actual.validateTree()
 
     assert actual == expected
 
 
 def test_normalize_branch_converge():
-    blockEnd = TealSimpleBlock([])
-    blockTrueNext = TealSimpleBlock([TealOp(None, Op.int, 4)])
+    blockEnd = pt.TealSimpleBlock([])
+    blockTrueNext = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 4)])
     blockTrueNext.setNextBlock(blockEnd)
-    blockTrue = TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+    blockTrue = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     blockTrue.setNextBlock(blockTrueNext)
-    blockFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
+    blockFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
     blockFalse.setNextBlock(blockEnd)
-    blockBranch = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    blockBranch = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     blockBranch.setTrueBlock(blockTrue)
     blockBranch.setFalseBlock(blockFalse)
-    original = TealSimpleBlock([])
+    original = pt.TealSimpleBlock([])
     original.setNextBlock(blockBranch)
 
-    expectedEnd = TealSimpleBlock([])
-    expectedTrue = TealSimpleBlock(
-        [TealOp(None, Op.byte, '"true"'), TealOp(None, Op.int, 4)]
+    expectedEnd = pt.TealSimpleBlock([])
+    expectedTrue = pt.TealSimpleBlock(
+        [pt.TealOp(None, pt.Op.byte, '"true"'), pt.TealOp(None, pt.Op.int, 4)]
     )
     expectedTrue.setNextBlock(expectedEnd)
-    expectedFalse = TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
+    expectedFalse = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
     expectedFalse.setNextBlock(expectedEnd)
-    expected = TealConditionalBlock([TealOp(None, Op.int, 1)])
+    expected = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
     expected.setTrueBlock(expectedTrue)
     expected.setFalseBlock(expectedFalse)
 
     original.addIncoming()
-    actual = TealBlock.NormalizeBlocks(original)
+    actual = pt.TealBlock.NormalizeBlocks(original)
     actual.validateTree()
 
     assert actual == expected
diff --git a/pyteal/ir/tealcomponent_test.py b/pyteal/ir/tealcomponent_test.py
index 81ac8c7a5..acda8ccf8 100644
--- a/pyteal/ir/tealcomponent_test.py
+++ b/pyteal/ir/tealcomponent_test.py
@@ -1,21 +1,19 @@
-import pytest
-
-from .. import *
+import pyteal as pt
 
 
 def test_EqualityContext():
-    expr1 = Int(1)
-    expr2 = Int(1)
+    expr1 = pt.Int(1)
+    expr2 = pt.Int(1)
 
-    op1 = TealOp(expr1, Op.int, 1)
-    op2 = TealOp(expr2, Op.int, 1)
+    op1 = pt.TealOp(expr1, pt.Op.int, 1)
+    op2 = pt.TealOp(expr2, pt.Op.int, 1)
 
     assert op1 == op1
     assert op2 == op2
     assert op1 != op2
     assert op2 != op1
 
-    with TealComponent.Context.ignoreExprEquality():
+    with pt.TealComponent.Context.ignoreExprEquality():
         assert op1 == op1
         assert op2 == op2
         assert op1 == op2
diff --git a/pyteal/ir/tealconditionalblock_test.py b/pyteal/ir/tealconditionalblock_test.py
index 7139adc24..3177ff390 100644
--- a/pyteal/ir/tealconditionalblock_test.py
+++ b/pyteal/ir/tealconditionalblock_test.py
@@ -1,51 +1,57 @@
-from .. import *
+import pyteal as pt
 
 
 def test_constructor():
-    block1 = TealConditionalBlock([])
+    block1 = pt.TealConditionalBlock([])
     assert block1.ops == []
     assert block1.trueBlock is None
     assert block1.falseBlock is None
 
-    block2 = TealConditionalBlock([TealOp(None, Op.int, 1)])
-    assert block2.ops == [TealOp(None, Op.int, 1)]
+    block2 = pt.TealConditionalBlock([pt.TealOp(None, pt.Op.int, 1)])
+    assert block2.ops == [pt.TealOp(None, pt.Op.int, 1)]
     assert block2.trueBlock is None
     assert block2.falseBlock is None
 
 
 def test_true_block():
-    block = TealConditionalBlock([])
-    block.setTrueBlock(TealSimpleBlock([TealOp(None, Op.substring3)]))
-    assert block.trueBlock == TealSimpleBlock([TealOp(None, Op.substring3)])
-    assert block.getOutgoing() == [TealSimpleBlock([TealOp(None, Op.substring3)])]
+    block = pt.TealConditionalBlock([])
+    block.setTrueBlock(pt.TealSimpleBlock([pt.TealOp(None, pt.Op.substring3)]))
+    assert block.trueBlock == pt.TealSimpleBlock([pt.TealOp(None, pt.Op.substring3)])
+    assert block.getOutgoing() == [
+        pt.TealSimpleBlock([pt.TealOp(None, pt.Op.substring3)])
+    ]
 
 
 def test_false_block():
-    block = TealConditionalBlock([])
-    block.setFalseBlock(TealSimpleBlock([TealOp(None, Op.substring3)]))
-    assert block.falseBlock == TealSimpleBlock([TealOp(None, Op.substring3)])
+    block = pt.TealConditionalBlock([])
+    block.setFalseBlock(pt.TealSimpleBlock([pt.TealOp(None, pt.Op.substring3)]))
+    assert block.falseBlock == pt.TealSimpleBlock([pt.TealOp(None, pt.Op.substring3)])
 
 
 def test_outgoing():
-    emptyBlock = TealConditionalBlock([])
+    emptyBlock = pt.TealConditionalBlock([])
     assert emptyBlock.getOutgoing() == []
 
-    trueBlock = TealConditionalBlock([])
-    trueBlock.setTrueBlock(TealSimpleBlock([TealOp(None, Op.byte, '"true"')]))
+    trueBlock = pt.TealConditionalBlock([])
+    trueBlock.setTrueBlock(pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')]))
     assert trueBlock.getOutgoing() == [
-        TealSimpleBlock([TealOp(None, Op.byte, '"true"')])
+        pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')])
     ]
 
-    falseBlock = TealConditionalBlock([])
-    falseBlock.setFalseBlock(TealSimpleBlock([TealOp(None, Op.byte, '"false"')]))
+    falseBlock = pt.TealConditionalBlock([])
+    falseBlock.setFalseBlock(
+        pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
+    )
     assert falseBlock.getOutgoing() == [
-        TealSimpleBlock([TealOp(None, Op.byte, '"false"')])
+        pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
     ]
 
-    bothBlock = TealConditionalBlock([])
-    bothBlock.setTrueBlock(TealSimpleBlock([TealOp(None, Op.byte, '"true"')]))
-    bothBlock.setFalseBlock(TealSimpleBlock([TealOp(None, Op.byte, '"false"')]))
+    bothBlock = pt.TealConditionalBlock([])
+    bothBlock.setTrueBlock(pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')]))
+    bothBlock.setFalseBlock(
+        pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')])
+    )
     assert bothBlock.getOutgoing() == [
-        TealSimpleBlock([TealOp(None, Op.byte, '"true"')]),
-        TealSimpleBlock([TealOp(None, Op.byte, '"false"')]),
+        pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"true"')]),
+        pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"false"')]),
     ]
diff --git a/pyteal/ir/tealsimpleblock_test.py b/pyteal/ir/tealsimpleblock_test.py
index 78893d60f..8ad2465c2 100644
--- a/pyteal/ir/tealsimpleblock_test.py
+++ b/pyteal/ir/tealsimpleblock_test.py
@@ -1,28 +1,28 @@
-from .. import *
+import pyteal as pt
 
 
 def test_constructor():
-    block1 = TealSimpleBlock([])
+    block1 = pt.TealSimpleBlock([])
     assert block1.ops == []
     assert block1.nextBlock is None
 
-    block2 = TealSimpleBlock([TealOp(None, Op.int, 1)])
-    assert block2.ops == [TealOp(None, Op.int, 1)]
+    block2 = pt.TealSimpleBlock([pt.TealOp(None, pt.Op.int, 1)])
+    assert block2.ops == [pt.TealOp(None, pt.Op.int, 1)]
     assert block2.nextBlock is None
 
 
 def test_next_block():
-    block = TealSimpleBlock([])
-    block.setNextBlock(TealSimpleBlock([TealOp(None, Op.substring3)]))
-    assert block.nextBlock == TealSimpleBlock([TealOp(None, Op.substring3)])
+    block = pt.TealSimpleBlock([])
+    block.setNextBlock(pt.TealSimpleBlock([pt.TealOp(None, pt.Op.substring3)]))
+    assert block.nextBlock == pt.TealSimpleBlock([pt.TealOp(None, pt.Op.substring3)])
 
 
 def test_outgoing():
-    emptyBlock = TealSimpleBlock([])
+    emptyBlock = pt.TealSimpleBlock([])
     assert emptyBlock.getOutgoing() == []
 
-    block = TealSimpleBlock([])
-    block.setNextBlock(TealSimpleBlock([TealOp(None, Op.byte, '"nextBlock"')]))
+    block = pt.TealSimpleBlock([])
+    block.setNextBlock(pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"nextBlock"')]))
     assert block.getOutgoing() == [
-        TealSimpleBlock([TealOp(None, Op.byte, '"nextBlock"')])
+        pt.TealSimpleBlock([pt.TealOp(None, pt.Op.byte, '"nextBlock"')])
     ]
diff --git a/pyteal/types_test.py b/pyteal/types_test.py
index c6d38d2a9..2c1f61674 100644
--- a/pyteal/types_test.py
+++ b/pyteal/types_test.py
@@ -1,13 +1,14 @@
-from . import *
-from .types import require_type
 import pytest
 
+import pyteal as pt
+from .types import require_type
+
 
 def test_require_type():
-    require_type(Bytes("str"), TealType.bytes)
+    require_type(pt.Bytes("str"), pt.TealType.bytes)
     assert True
 
 
 def test_require_type_invalid():
     with pytest.raises(TypeError):
-        App.globalGet(["This is certainly invalid"])
+        pt.App.globalGet(["This is certainly invalid"])
diff --git a/tests/compile_test.py b/tests/compile_test.py
index 282c8d123..f6ba6d030 100644
--- a/tests/compile_test.py
+++ b/tests/compile_test.py
@@ -1,7 +1,7 @@
 import os
 import pytest
 
-from pyteal import *
+import pyteal as pt
 
 
 def test_basic_bank():
@@ -16,7 +16,7 @@ def test_basic_bank():
     )
     with open(target_path, "r") as target_file:
         target = "".join(target_file.readlines()).strip()
-        assert compileTeal(program, mode=Mode.Signature, version=3) == target
+        assert pt.compileTeal(program, mode=pt.Mode.Signature, version=3) == target
 
 
 def test_atomic_swap():
@@ -29,7 +29,7 @@ def test_atomic_swap():
     )
     with open(target_path, "r") as target_file:
         target = "".join(target_file.readlines()).strip()
-        assert compileTeal(program, mode=Mode.Signature, version=2) == target
+        assert pt.compileTeal(program, mode=pt.Mode.Signature, version=2) == target
 
 
 def test_periodic_payment():
@@ -42,7 +42,7 @@ def test_periodic_payment():
     )
     with open(target_path, "r") as target_file:
         target = "".join(target_file.readlines()).strip()
-        assert compileTeal(program, mode=Mode.Signature, version=2) == target
+        assert pt.compileTeal(program, mode=pt.Mode.Signature, version=2) == target
 
 
 def test_split():
@@ -55,7 +55,7 @@ def test_split():
     )
     with open(target_path, "r") as target_file:
         target = "".join(target_file.readlines()).strip()
-        assert compileTeal(program, mode=Mode.Signature, version=2) == target
+        assert pt.compileTeal(program, mode=pt.Mode.Signature, version=2) == target
 
 
 def test_dutch_auction():
@@ -68,7 +68,7 @@ def test_dutch_auction():
     )
     with open(target_path, "r") as target_file:
         target = "".join(target_file.readlines()).strip()
-        assert compileTeal(program, mode=Mode.Signature, version=2) == target
+        assert pt.compileTeal(program, mode=pt.Mode.Signature, version=2) == target
 
 
 def test_recurring_swap():
@@ -81,7 +81,7 @@ def test_recurring_swap():
     )
     with open(target_path, "r") as target_file:
         target = "".join(target_file.readlines()).strip()
-        assert compileTeal(program, mode=Mode.Signature, version=2) == target
+        assert pt.compileTeal(program, mode=pt.Mode.Signature, version=2) == target
 
 
 def test_asset():
@@ -91,8 +91,8 @@ def test_asset():
     clear_state = clear_state_program()
 
     # only checking for successful compilation for now
-    compileTeal(approval, mode=Mode.Application, version=2)
-    compileTeal(clear_state, mode=Mode.Application, version=2)
+    pt.compileTeal(approval, mode=pt.Mode.Application, version=2)
+    pt.compileTeal(clear_state, mode=pt.Mode.Application, version=2)
 
 
 def test_security_token():
@@ -105,8 +105,8 @@ def test_security_token():
     clear_state = clear_state_program()
 
     # only checking for successful compilation for now
-    compileTeal(approval, mode=Mode.Application, version=2)
-    compileTeal(clear_state, mode=Mode.Application, version=2)
+    pt.compileTeal(approval, mode=pt.Mode.Application, version=2)
+    pt.compileTeal(clear_state, mode=pt.Mode.Application, version=2)
 
 
 def test_vote():
@@ -116,40 +116,40 @@ def test_vote():
     clear_state = clear_state_program()
 
     # only checking for successful compilation for now
-    compileTeal(approval, mode=Mode.Application, version=2)
-    compileTeal(clear_state, mode=Mode.Application, version=2)
+    pt.compileTeal(approval, mode=pt.Mode.Application, version=2)
+    pt.compileTeal(clear_state, mode=pt.Mode.Application, version=2)
 
 
 def test_cond():
-    cond1 = Txn.fee() < Int(2000)
-    cond2 = Txn.amount() > Int(5000)
-    cond3 = Txn.receiver() == Txn.sender()
-    core = Cond(
-        [Global.group_size() == Int(2), cond1],
-        [Global.group_size() == Int(3), cond2],
-        [Global.group_size() == Int(4), cond3],
+    cond1 = pt.Txn.fee() < pt.Int(2000)
+    cond2 = pt.Txn.amount() > pt.Int(5000)
+    cond3 = pt.Txn.receiver() == pt.Txn.sender()
+    core = pt.Cond(
+        [pt.Global.group_size() == pt.Int(2), cond1],
+        [pt.Global.group_size() == pt.Int(3), cond2],
+        [pt.Global.group_size() == pt.Int(4), cond3],
     )
-    compileTeal(core, mode=Mode.Signature, version=2)
+    pt.compileTeal(core, mode=pt.Mode.Signature, version=2)
 
 
 @pytest.mark.timeout(2)
 def test_many_ifs():
     """
-    Test with many If statements to trigger potential corner cases in code generation.
+    Test with many pt.If statements to trigger potential corner cases in code generation.
     Previous versions of PyTeal took an exponential time to generate the TEAL code for this PyTEAL.
     """
 
-    sv = ScratchVar(TealType.uint64)
-    s = Seq(
+    sv = pt.ScratchVar(pt.TealType.uint64)
+    s = pt.Seq(
         [
-            If(
-                Int(3 * i) == Int(3 * i),
-                sv.store(Int(3 * i + 1)),
-                sv.store(Int(3 * i + 2)),
+            pt.If(
+                pt.Int(3 * i) == pt.Int(3 * i),
+                sv.store(pt.Int(3 * i + 1)),
+                sv.store(pt.Int(3 * i + 2)),
             )
             for i in range(30)
         ]
-        + [Return(sv.load())]
+        + [pt.Return(sv.load())]
     )
 
-    compileTeal(s, mode=Mode.Signature, version=2)
+    pt.compileTeal(s, mode=pt.Mode.Signature, version=2)
diff --git a/tests/pass_by_ref_test.py b/tests/pass_by_ref_test.py
index e0c12d000..f92300caa 100644
--- a/tests/pass_by_ref_test.py
+++ b/tests/pass_by_ref_test.py
@@ -1,176 +1,178 @@
-from typing import List, Tuple
-
 import pytest
 
-from pyteal import *
+import pyteal as pt
 
-from .compile_asserts import assert_new_v_old, compile_and_save
+from .compile_asserts import assert_new_v_old
 
 # TODO: remove these skips when the following is fixed: https://github.com/algorand/pyteal/issues/199
 STABLE_SLOT_GENERATION = False
 
-#### TESTS FOR NEW PyTEAL THAT USES PASS-BY-REF / DYNAMIC
-@Subroutine(TealType.none)
-def logcat_dynamic(first: ScratchVar, an_int):
-    return Seq(
-        first.store(Concat(first.load(), Itob(an_int))),
-        Log(first.load()),
+# ### TESTS FOR NEW PyTEAL THAT USES PASS-BY-REF / DYNAMIC
+@pt.Subroutine(pt.TealType.none)
+def logcat_dynamic(first: pt.ScratchVar, an_int):
+    return pt.Seq(
+        first.store(pt.Concat(first.load(), pt.Itob(an_int))),
+        pt.Log(first.load()),
     )
 
 
 def sub_logcat_dynamic():
-    first = ScratchVar(TealType.bytes)
-    return Seq(
-        first.store(Bytes("hello")),
-        logcat_dynamic(first, Int(42)),
-        Assert(Bytes("hello42") == first.load()),
-        Int(1),
+    first = pt.ScratchVar(pt.TealType.bytes)
+    return pt.Seq(
+        first.store(pt.Bytes("hello")),
+        logcat_dynamic(first, pt.Int(42)),
+        pt.Assert(pt.Bytes("hello42") == first.load()),
+        pt.Int(1),
     )
 
 
 def wilt_the_stilt():
-    player_score = DynamicScratchVar(TealType.uint64)
+    player_score = pt.DynamicScratchVar(pt.TealType.uint64)
 
-    wilt = ScratchVar(TealType.uint64, 129)
-    kobe = ScratchVar(TealType.uint64)
-    dt = ScratchVar(TealType.uint64, 131)
+    wilt = pt.ScratchVar(pt.TealType.uint64, 129)
+    kobe = pt.ScratchVar(pt.TealType.uint64)
+    dt = pt.ScratchVar(pt.TealType.uint64, 131)
 
-    return Seq(
+    return pt.Seq(
         player_score.set_index(wilt),
-        player_score.store(Int(100)),
+        player_score.store(pt.Int(100)),
         player_score.set_index(kobe),
-        player_score.store(Int(81)),
+        player_score.store(pt.Int(81)),
         player_score.set_index(dt),
-        player_score.store(Int(73)),
-        Assert(player_score.load() == Int(73)),
-        Assert(player_score.index() == Int(131)),
+        player_score.store(pt.Int(73)),
+        pt.Assert(player_score.load() == pt.Int(73)),
+        pt.Assert(player_score.index() == pt.Int(131)),
         player_score.set_index(wilt),
-        Assert(player_score.load() == Int(100)),
-        Assert(player_score.index() == Int(129)),
-        Int(100),
+        pt.Assert(player_score.load() == pt.Int(100)),
+        pt.Assert(player_score.index() == pt.Int(129)),
+        pt.Int(100),
     )
 
 
-@Subroutine(TealType.none)
-def swap(x: ScratchVar, y: ScratchVar):
-    z = ScratchVar(TealType.anytype)
-    return Seq(
+@pt.Subroutine(pt.TealType.none)
+def swap(x: pt.ScratchVar, y: pt.ScratchVar):
+    z = pt.ScratchVar(pt.TealType.anytype)
+    return pt.Seq(
         z.store(x.load()),
         x.store(y.load()),
         y.store(z.load()),
     )
 
 
-@Subroutine(TealType.none)
+@pt.Subroutine(pt.TealType.none)
 def cat(x, y):
-    return Pop(Concat(x, y))
+    return pt.Pop(pt.Concat(x, y))
 
 
 def swapper():
-    a = ScratchVar(TealType.bytes)
-    b = ScratchVar(TealType.bytes)
-    return Seq(
-        a.store(Bytes("hello")),
-        b.store(Bytes("goodbye")),
+    a = pt.ScratchVar(pt.TealType.bytes)
+    b = pt.ScratchVar(pt.TealType.bytes)
+    return pt.Seq(
+        a.store(pt.Bytes("hello")),
+        b.store(pt.Bytes("goodbye")),
         cat(a.load(), b.load()),
         swap(a, b),
-        Assert(a.load() == Bytes("goodbye")),
-        Assert(b.load() == Bytes("hello")),
-        Int(1000),
+        pt.Assert(a.load() == pt.Bytes("goodbye")),
+        pt.Assert(b.load() == pt.Bytes("hello")),
+        pt.Int(1000),
     )
 
 
-@Subroutine(TealType.uint64)
-def mixed_annotations(x: Expr, y: Expr, z: ScratchVar) -> Expr:
-    return Seq(
+@pt.Subroutine(pt.TealType.uint64)
+def mixed_annotations(x: pt.Expr, y: pt.Expr, z: pt.ScratchVar) -> pt.Expr:
+    return pt.Seq(
         z.store(x),
-        Log(Concat(y, Bytes("="), Itob(x))),
+        pt.Log(pt.Concat(y, pt.Bytes("="), pt.Itob(x))),
         x,
     )
 
 
 def sub_mixed():
-    x = Int(42)
-    y = Bytes("x")
-    z = ScratchVar(TealType.uint64)
+    x = pt.Int(42)
+    y = pt.Bytes("x")
+    z = pt.ScratchVar(pt.TealType.uint64)
     return mixed_annotations(x, y, z)
 
 
 def lots_o_vars():
-    z = Int(0)
-    one = ScratchVar()
-    two = ScratchVar()
-    three = ScratchVar()
-    four = ScratchVar()
-    five = Bytes("five")
-    six = Bytes("six")
-    seven = Bytes("seven")
-    eight = Bytes("eight")
-    nine = Bytes("nine")
-    ten = Bytes("ten")
-    eleven = Bytes("eleven")
-    twelve = Bytes("twelve")
-    int_cursor = DynamicScratchVar(TealType.uint64)
-    bytes_cursor = DynamicScratchVar(TealType.bytes)
-    thirteen = ScratchVar(TealType.uint64, 13)
-    fourteen = ScratchVar(TealType.bytes, 14)
-    fifteen = ScratchVar(TealType.uint64)
-    sixteen = ScratchVar(TealType.bytes)
-    leet = Int(1337)
-    ngl = Bytes("NGL: ")
+    z = pt.Int(0)
+    one = pt.ScratchVar()
+    two = pt.ScratchVar()
+    three = pt.ScratchVar()
+    four = pt.ScratchVar()
+    five = pt.Bytes("five")
+    six = pt.Bytes("six")
+    seven = pt.Bytes("seven")
+    eight = pt.Bytes("eight")
+    nine = pt.Bytes("nine")
+    ten = pt.Bytes("ten")
+    eleven = pt.Bytes("eleven")
+    twelve = pt.Bytes("twelve")
+    int_cursor = pt.DynamicScratchVar(pt.TealType.uint64)
+    bytes_cursor = pt.DynamicScratchVar(pt.TealType.bytes)
+    thirteen = pt.ScratchVar(pt.TealType.uint64, 13)
+    fourteen = pt.ScratchVar(pt.TealType.bytes, 14)
+    fifteen = pt.ScratchVar(pt.TealType.uint64)
+    sixteen = pt.ScratchVar(pt.TealType.bytes)
+    leet = pt.Int(1337)
+    ngl = pt.Bytes("NGL: ")
     return (
-        If(Or(App.id() == Int(0), Txn.application_args.length() == Int(0)))
-        .Then(Int(1))
+        pt.If(
+            pt.Or(
+                pt.App.id() == pt.Int(0), pt.Txn.application_args.length() == pt.Int(0)
+            )
+        )
+        .Then(pt.Int(1))
         .Else(
-            Seq(
-                one.store(Int(1)),
-                two.store(Bytes("two")),
-                three.store(Int(3)),
-                four.store(Bytes("four")),
-                App.localPut(z, five, Int(5)),
-                App.localPut(z, six, six),
-                App.localPut(z, seven, Int(7)),
-                App.localPut(z, eight, eight),
-                App.globalPut(nine, Int(9)),
-                App.globalPut(ten, ten),
-                App.globalPut(eleven, Int(11)),
-                App.globalPut(twelve, twelve),
+            pt.Seq(
+                one.store(pt.Int(1)),
+                two.store(pt.Bytes("two")),
+                three.store(pt.Int(3)),
+                four.store(pt.Bytes("four")),
+                pt.App.localPut(z, five, pt.Int(5)),
+                pt.App.localPut(z, six, six),
+                pt.App.localPut(z, seven, pt.Int(7)),
+                pt.App.localPut(z, eight, eight),
+                pt.App.globalPut(nine, pt.Int(9)),
+                pt.App.globalPut(ten, ten),
+                pt.App.globalPut(eleven, pt.Int(11)),
+                pt.App.globalPut(twelve, twelve),
                 one.store(one.load() + leet),
-                two.store(Concat(ngl, two.load())),
+                two.store(pt.Concat(ngl, two.load())),
                 three.store(three.load() + leet),
-                four.store(Concat(ngl, four.load())),
-                App.localPut(z, five, leet + App.localGet(z, five)),
-                App.localPut(z, six, Concat(ngl, App.localGet(z, six))),
-                App.localPut(z, seven, App.localGet(z, seven)),
-                App.localPut(z, eight, Concat(ngl, App.localGet(z, eight))),
-                App.globalPut(nine, leet + App.globalGet(nine)),
-                App.globalPut(ten, Concat(ngl, App.globalGet(ten))),
-                App.globalPut(eleven, leet + App.globalGet(eleven)),
-                App.globalPut(twelve, Concat(ngl, App.globalGet(twelve))),
-                thirteen.store(Btoi(Txn.application_args[0])),
-                fourteen.store(Txn.application_args[1]),
-                fifteen.store(Btoi(Txn.application_args[2])),
-                sixteen.store(Txn.application_args[3]),
-                Pop(one.load()),
-                Pop(two.load()),
-                Pop(three.load()),
-                Pop(four.load()),
-                Pop(App.localGet(z, five)),
-                Pop(App.localGet(z, six)),
-                Pop(App.localGet(z, seven)),
-                Pop(App.localGet(z, eight)),
-                Pop(App.globalGet(nine)),
-                Pop(App.globalGet(ten)),
-                Pop(App.globalGet(eleven)),
-                Pop(App.globalGet(twelve)),
+                four.store(pt.Concat(ngl, four.load())),
+                pt.App.localPut(z, five, leet + pt.App.localGet(z, five)),
+                pt.App.localPut(z, six, pt.Concat(ngl, pt.App.localGet(z, six))),
+                pt.App.localPut(z, seven, pt.App.localGet(z, seven)),
+                pt.App.localPut(z, eight, pt.Concat(ngl, pt.App.localGet(z, eight))),
+                pt.App.globalPut(nine, leet + pt.App.globalGet(nine)),
+                pt.App.globalPut(ten, pt.Concat(ngl, pt.App.globalGet(ten))),
+                pt.App.globalPut(eleven, leet + pt.App.globalGet(eleven)),
+                pt.App.globalPut(twelve, pt.Concat(ngl, pt.App.globalGet(twelve))),
+                thirteen.store(pt.Btoi(pt.Txn.application_args[0])),
+                fourteen.store(pt.Txn.application_args[1]),
+                fifteen.store(pt.Btoi(pt.Txn.application_args[2])),
+                sixteen.store(pt.Txn.application_args[3]),
+                pt.Pop(one.load()),
+                pt.Pop(two.load()),
+                pt.Pop(three.load()),
+                pt.Pop(four.load()),
+                pt.Pop(pt.App.localGet(z, five)),
+                pt.Pop(pt.App.localGet(z, six)),
+                pt.Pop(pt.App.localGet(z, seven)),
+                pt.Pop(pt.App.localGet(z, eight)),
+                pt.Pop(pt.App.globalGet(nine)),
+                pt.Pop(pt.App.globalGet(ten)),
+                pt.Pop(pt.App.globalGet(eleven)),
+                pt.Pop(pt.App.globalGet(twelve)),
                 int_cursor.set_index(thirteen),
-                Log(Itob(int_cursor.load())),
+                pt.Log(pt.Itob(int_cursor.load())),
                 bytes_cursor.set_index(fourteen),
-                Log(bytes_cursor.load()),
+                pt.Log(bytes_cursor.load()),
                 int_cursor.set_index(fifteen),
-                Log(Itob(int_cursor.load())),
+                pt.Log(pt.Itob(int_cursor.load())),
                 bytes_cursor.set_index(sixteen),
-                Log(bytes_cursor.load()),
+                pt.Log(bytes_cursor.load()),
                 leet,
             )
         )
@@ -178,33 +180,33 @@ def lots_o_vars():
 
 
 def empty_scratches():
-    cursor = DynamicScratchVar()
-    i1 = ScratchVar(TealType.uint64, 0)
-    i2 = ScratchVar(TealType.uint64, 2)
-    i3 = ScratchVar(TealType.uint64, 4)
-    s1 = ScratchVar(TealType.bytes, 1)
-    s2 = ScratchVar(TealType.bytes, 3)
-    s3 = ScratchVar(TealType.bytes, 5)
-    return Seq(
+    cursor = pt.DynamicScratchVar()
+    i1 = pt.ScratchVar(pt.TealType.uint64, 0)
+    i2 = pt.ScratchVar(pt.TealType.uint64, 2)
+    i3 = pt.ScratchVar(pt.TealType.uint64, 4)
+    s1 = pt.ScratchVar(pt.TealType.bytes, 1)
+    s2 = pt.ScratchVar(pt.TealType.bytes, 3)
+    s3 = pt.ScratchVar(pt.TealType.bytes, 5)
+    return pt.Seq(
         cursor.set_index(i1),
-        cursor.store(Int(0)),
+        cursor.store(pt.Int(0)),
         cursor.set_index(s1),
-        cursor.store(Bytes("")),
+        cursor.store(pt.Bytes("")),
         cursor.set_index(i2),
-        cursor.store(Int(0)),
+        cursor.store(pt.Int(0)),
         cursor.set_index(s2),
-        cursor.store(Bytes("")),
+        cursor.store(pt.Bytes("")),
         cursor.set_index(i3),
-        cursor.store(Int(0)),
+        cursor.store(pt.Int(0)),
         cursor.set_index(s3),
-        cursor.store(Bytes("")),
-        Int(42),
+        cursor.store(pt.Bytes("")),
+        pt.Int(42),
     )
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def oldfac(n):
-    return If(n < Int(2)).Then(Int(1)).Else(n * oldfac(n - Int(1)))
+    return pt.If(n < pt.Int(2)).Then(pt.Int(1)).Else(n * oldfac(n - pt.Int(1)))
 
 
 CASES = (
@@ -223,41 +225,41 @@ def test_teal_output_is_unchanged(pt):
     assert_new_v_old(pt, 6)
 
 
-##### Subroutine Definitions for pass-by-ref guardrails testing #####
-@Subroutine(TealType.uint64)
+# #### pt.Subroutine Definitions for pass-by-ref guardrails testing #####
+@pt.Subroutine(pt.TealType.uint64)
 def ok(x):
     # not really ok at runtime... but should be ok at compile time
     return ok(x)
 
 
-@Subroutine(TealType.uint64)
-def ok_byref(x: ScratchVar):
-    return Int(42)
+@pt.Subroutine(pt.TealType.uint64)
+def ok_byref(x: pt.ScratchVar):
+    return pt.Int(42)
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def ok_indirect1(x):
     return ok_indirect2(x)
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def ok_indirect2(x):
     return ok_indirect1(x)
 
 
-@Subroutine(TealType.uint64)
-def not_ok(x: ScratchVar):
+@pt.Subroutine(pt.TealType.uint64)
+def not_ok(x: pt.ScratchVar):
     # not ok both at compile and runtime
     return not_ok(x)
 
 
-@Subroutine(TealType.uint64)
-def not_ok_indirect1(x: ScratchVar):
+@pt.Subroutine(pt.TealType.uint64)
+def not_ok_indirect1(x: pt.ScratchVar):
     return not_ok_indirect2(x)
 
 
-@Subroutine(TealType.uint64)
-def not_ok_indirect2(x: ScratchVar):
+@pt.Subroutine(pt.TealType.uint64)
+def not_ok_indirect2(x: pt.ScratchVar):
     return not_ok_indirect1(x)
 
 
@@ -278,96 +280,96 @@ def not_ok_indirect2(x: ScratchVar):
 """
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def a(x):
-    tmp = ScratchVar(TealType.uint64)
-    return Seq(tmp.store(x), b(x) + c(tmp) + d(x))
+    tmp = pt.ScratchVar(pt.TealType.uint64)
+    return pt.Seq(tmp.store(x), b(x) + c(tmp) + d(x))
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def b(x):
     return a(x) + e(x) * f(x)
 
 
-@Subroutine(TealType.uint64)
-def c(x: ScratchVar):
-    return g(Int(42)) - h(x.load())
+@pt.Subroutine(pt.TealType.uint64)
+def c(x: pt.ScratchVar):
+    return g(pt.Int(42)) - h(x.load())
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def d(x):
-    return d(x) + i(Int(11)) * j(x)
+    return d(x) + i(pt.Int(11)) * j(x)
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def e(x):
-    return Int(42)
+    return pt.Int(42)
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def f(x):
-    return Int(42)
+    return pt.Int(42)
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def g(x):
-    return a(Int(17))
+    return a(pt.Int(17))
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def h(x):
-    return Int(42)
+    return pt.Int(42)
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def i(x):
-    return Int(42)
+    return pt.Int(42)
 
 
-@Subroutine(TealType.uint64)
+@pt.Subroutine(pt.TealType.uint64)
 def j(x):
-    return Int(42)
+    return pt.Int(42)
 
 
-@Subroutine(TealType.none)
-def tally(n, result: ScratchVar):
+@pt.Subroutine(pt.TealType.none)
+def tally(n, result: pt.ScratchVar):
     return (
-        If(n == Int(0))
-        .Then(result.store(Bytes("")))
+        pt.If(n == pt.Int(0))
+        .Then(result.store(pt.Bytes("")))
         .Else(
-            Seq(
-                tally(n - Int(1), result),
-                result.store(Concat(result.load(), Bytes("a"))),
+            pt.Seq(
+                tally(n - pt.Int(1), result),
+                result.store(pt.Concat(result.load(), pt.Bytes("a"))),
             )
         )
     )
 
 
-@Subroutine(TealType.none)
-def subr_string_mult(s: ScratchVar, n):
-    tmp = ScratchVar(TealType.bytes)
+@pt.Subroutine(pt.TealType.none)
+def subr_string_mult(s: pt.ScratchVar, n):
+    tmp = pt.ScratchVar(pt.TealType.bytes)
     return (
-        If(n == Int(0))
-        .Then(s.store(Bytes("")))
+        pt.If(n == pt.Int(0))
+        .Then(s.store(pt.Bytes("")))
         .Else(
-            Seq(
+            pt.Seq(
                 tmp.store(s.load()),
-                subr_string_mult(s, n - Int(1)),
-                s.store(Concat(s.load(), tmp.load())),
+                subr_string_mult(s, n - pt.Int(1)),
+                s.store(pt.Concat(s.load(), tmp.load())),
             )
         )
     )
 
 
-@Subroutine(TealType.none)
-def factorial_BAD(n: ScratchVar):
-    tmp = ScratchVar(TealType.uint64)
+@pt.Subroutine(pt.TealType.none)
+def factorial_BAD(n: pt.ScratchVar):
+    tmp = pt.ScratchVar(pt.TealType.uint64)
     return (
-        If(n.load() <= Int(1))
-        .Then(n.store(Int(1)))
+        pt.If(n.load() <= pt.Int(1))
+        .Then(n.store(pt.Int(1)))
         .Else(
-            Seq(
-                tmp.store(n.load() - Int(1)),
+            pt.Seq(
+                tmp.store(n.load() - pt.Int(1)),
                 factorial_BAD(tmp),
                 n.store(n.load() * tmp.load()),
             )
@@ -375,16 +377,16 @@ def factorial_BAD(n: ScratchVar):
     )
 
 
-@Subroutine(TealType.none)
-def factorial(n: ScratchVar):
-    tmp = ScratchVar(TealType.uint64)
+@pt.Subroutine(pt.TealType.none)
+def factorial(n: pt.ScratchVar):
+    tmp = pt.ScratchVar(pt.TealType.uint64)
     return (
-        If(n.load() <= Int(1))
-        .Then(n.store(Int(1)))
+        pt.If(n.load() <= pt.Int(1))
+        .Then(n.store(pt.Int(1)))
         .Else(
-            Seq(
+            pt.Seq(
                 tmp.store(n.load()),
-                n.store(n.load() - Int(1)),
+                n.store(n.load() - pt.Int(1)),
                 factorial(n),
                 n.store(n.load() * tmp.load()),
             )
@@ -392,82 +394,90 @@ def factorial(n: ScratchVar):
     )
 
 
-@Subroutine(TealType.none)
-def plus_one(n: ScratchVar):
-    tmp = ScratchVar(TealType.uint64)
+@pt.Subroutine(pt.TealType.none)
+def plus_one(n: pt.ScratchVar):
+    tmp = pt.ScratchVar(pt.TealType.uint64)
     return (
-        If(n.load() == Int(0))
-        .Then(n.store(Int(1)))
+        pt.If(n.load() == pt.Int(0))
+        .Then(n.store(pt.Int(1)))
         .Else(
-            Seq(
-                tmp.store(n.load() - Int(1)),
+            pt.Seq(
+                tmp.store(n.load() - pt.Int(1)),
                 plus_one(tmp),
-                n.store(tmp.load() + Int(1)),
+                n.store(tmp.load() + pt.Int(1)),
             )
         )
     )
 
 
-##### Approval PyTEAL Expressions (COPACETIC) #####
+# #### Approval PyTEAL Expressions (COPACETIC) #####
 
-approval_ok = ok(Int(42))
+approval_ok = ok(pt.Int(42))
 
-x_scratchvar = ScratchVar(TealType.uint64)
+x_scratchvar = pt.ScratchVar(pt.TealType.uint64)
 
-approval_ok_byref = Seq(x_scratchvar.store(Int(42)), ok_byref(x_scratchvar))
+approval_ok_byref = pt.Seq(x_scratchvar.store(pt.Int(42)), ok_byref(x_scratchvar))
 
-approval_ok_indirect = ok_indirect1(Int(42))
+approval_ok_indirect = ok_indirect1(pt.Int(42))
 
-##### BANNED Approval PyTEAL Expressions (wrapped in a function) #####
+# #### BANNED Approval PyTEAL Expressions (wrapped in a function) #####
 
-approval_not_ok = lambda: Seq(x_scratchvar.store(Int(42)), not_ok(x_scratchvar))
 
-approval_not_ok_indirect = lambda: Seq(
-    x_scratchvar.store(Int(42)), not_ok_indirect1(x_scratchvar)
-)
+def approval_not_ok():
+    return pt.Seq(x_scratchvar.store(pt.Int(42)), not_ok(x_scratchvar))
+
+
+def approval_not_ok_indirect():
+    return pt.Seq(x_scratchvar.store(pt.Int(42)), not_ok_indirect1(x_scratchvar))
 
-approval_its_complicated = lambda: a(Int(42))
+
+def approval_its_complicated():
+    return a(pt.Int(42))
 
 
 def tallygo():
-    result = ScratchVar(TealType.bytes)
-    # If-Then is a hook for creating + opting in without providing any args
+    result = pt.ScratchVar(pt.TealType.bytes)
+    # pt.If-Then is a hook for creating + opting in without providing any args
     return (
-        If(Or(App.id() == Int(0), Txn.application_args.length() == Int(0)))
-        .Then(Int(1))
+        pt.If(
+            pt.Or(
+                pt.App.id() == pt.Int(0), pt.Txn.application_args.length() == pt.Int(0)
+            )
+        )
+        .Then(pt.Int(1))
         .Else(
-            Seq(
-                result.store(Bytes("dummy")),
-                tally(Int(4), result),
-                Btoi(result.load()),
+            pt.Seq(
+                result.store(pt.Bytes("dummy")),
+                tally(pt.Int(4), result),
+                pt.Btoi(result.load()),
             )
         )
     )
 
 
 def string_mult():
-    s = ScratchVar(TealType.bytes)
-    return Seq(
-        s.store(Txn.application_args[0]),
-        subr_string_mult(s, Btoi(Txn.application_args[1])),
-        Log(s.load()),
-        Int(100),
+    s = pt.ScratchVar(pt.TealType.bytes)
+    return pt.Seq(
+        s.store(pt.Txn.application_args[0]),
+        subr_string_mult(s, pt.Btoi(pt.Txn.application_args[1])),
+        pt.Log(s.load()),
+        pt.Int(100),
     )
 
 
 def fac_by_ref_BAD():
-    n = ScratchVar(TealType.uint64)
-    return Seq(
-        n.store(Int(10)),
+    n = pt.ScratchVar(pt.TealType.uint64)
+    return pt.Seq(
+        n.store(pt.Int(10)),
         factorial_BAD(n),
         n.load(),
     )
 
 
 def fac_by_ref():
-    n = ScratchVar(TealType.uint64)
-    return Seq(
-        n.store(Int(10)),
+    n = pt.ScratchVar(pt.TealType.uint64)
+    return pt.Seq(
+        n.store(pt.Int(10)),
         factorial(n),
         n.load(),
     )
@@ -475,13 +485,17 @@ def fac_by_ref():
 
 # Proved correct via blackbox testing, but BANNING for now
 def fac_by_ref_args():
-    n = ScratchVar(TealType.uint64)
-    return Seq(
-        If(Or(App.id() == Int(0), Txn.application_args.length() == Int(0)))
-        .Then(Int(1))
+    n = pt.ScratchVar(pt.TealType.uint64)
+    return pt.Seq(
+        pt.If(
+            pt.Or(
+                pt.App.id() == pt.Int(0), pt.Txn.application_args.length() == pt.Int(0)
+            )
+        )
+        .Then(pt.Int(1))
         .Else(
-            Seq(
-                n.store(Btoi(Txn.application_args[0])),
+            pt.Seq(
+                n.store(pt.Btoi(pt.Txn.application_args[0])),
                 factorial(n),
                 n.load(),
             )
@@ -490,8 +504,8 @@ def fac_by_ref_args():
 
 
 def increment():
-    n = ScratchVar(TealType.uint64)
-    return Seq(n.store(Int(4)), plus_one(n), Int(1))
+    n = pt.ScratchVar(pt.TealType.uint64)
+    return pt.Seq(n.store(pt.Int(4)), plus_one(n), pt.Int(1))
 
 
 COPACETIC_APPROVALS = [approval_ok, approval_ok_byref, approval_ok_indirect]
@@ -511,14 +525,14 @@ def increment():
 
 @pytest.mark.parametrize("approval", COPACETIC_APPROVALS)
 def test_pass_by_ref_guardrails_COPACETIC(approval):
-    assert compileTeal(approval, Mode.Application, version=6)
+    assert pt.compileTeal(approval, pt.Mode.Application, version=6)
 
 
 @pytest.mark.parametrize("approval_func_n_suffix", ILLEGAL_APPROVALS.items())
 def test_pass_by_ref_guardrails_BANNED(approval_func_n_suffix):
     approval, suffix = approval_func_n_suffix
-    with pytest.raises(TealInputError) as err:
-        compileTeal(approval(), Mode.Application, version=6)
+    with pytest.raises(pt.TealInputError) as err:
+        pt.compileTeal(approval(), pt.Mode.Application, version=6)
 
     prefix = "ScratchVar arguments not allowed in recursive subroutines, but a recursive call-path was detected: "
     assert f"{prefix}{suffix}" in str(err)
diff --git a/tests/user_guide_test.py b/tests/user_guide_test.py
index 57134ac3f..feb309161 100644
--- a/tests/user_guide_test.py
+++ b/tests/user_guide_test.py
@@ -1,55 +1,54 @@
-import re
 import pytest
 
-from pyteal import *
+import pyteal as pt
 
-from .compile_asserts import assert_new_v_old, compile_and_save
+from .compile_asserts import assert_new_v_old
 
 
-def user_guide_snippet_dynamic_scratch_var() -> Expr:
+def user_guide_snippet_dynamic_scratch_var() -> pt.Expr:
     """
-    The user guide docs use the test to illustrate `DynamicScratchVar` usage.  If the test breaks, then the user guide docs must be updated along with the test.
+    The user guide docs use the test to illustrate `pt.DynamicScratchVar` usage.  pt.If the test breaks, then the user guide docs must be updated along with the test.
     """
 
-    s = ScratchVar(TealType.uint64)
-    d = DynamicScratchVar(TealType.uint64)
+    s = pt.ScratchVar(pt.TealType.uint64)
+    d = pt.DynamicScratchVar(pt.TealType.uint64)
 
-    return Seq(
+    return pt.Seq(
         d.set_index(s),
-        s.store(Int(7)),
-        d.store(d.load() + Int(3)),
-        Assert(s.load() == Int(10)),
-        Int(1),
+        s.store(pt.Int(7)),
+        d.store(d.load() + pt.Int(3)),
+        pt.Assert(s.load() == pt.Int(10)),
+        pt.Int(1),
     )
 
 
 def user_guide_snippet_recursiveIsEven():
-    @Subroutine(TealType.uint64)
+    @pt.Subroutine(pt.TealType.uint64)
     def recursiveIsEven(i):
         return (
-            If(i == Int(0))
-            .Then(Int(1))
-            .ElseIf(i == Int(1))
-            .Then(Int(0))
-            .Else(recursiveIsEven(i - Int(2)))
+            pt.If(i == pt.Int(0))
+            .Then(pt.Int(1))
+            .ElseIf(i == pt.Int(1))
+            .Then(pt.Int(0))
+            .Else(recursiveIsEven(i - pt.Int(2)))
         )
 
-    return recursiveIsEven(Int(15))
+    return recursiveIsEven(pt.Int(15))
 
 
 def user_guide_snippet_ILLEGAL_recursion():
-    @Subroutine(TealType.none)
-    def ILLEGAL_recursion(i: ScratchVar):
+    @pt.Subroutine(pt.TealType.none)
+    def ILLEGAL_recursion(i: pt.ScratchVar):
         return (
-            If(i.load() == Int(0))
-            .Then(i.store(Int(1)))
-            .ElseIf(i.load() == Int(1))
-            .Then(i.store(Int(0)))
-            .Else(Seq(i.store(i.load() - Int(2)), ILLEGAL_recursion(i)))
+            pt.If(i.load() == pt.Int(0))
+            .Then(i.store(pt.Int(1)))
+            .ElseIf(i.load() == pt.Int(1))
+            .Then(i.store(pt.Int(0)))
+            .Else(pt.Seq(i.store(i.load() - pt.Int(2)), ILLEGAL_recursion(i)))
         )
 
-    i = ScratchVar(TealType.uint64)
-    return Seq(i.store(Int(15)), ILLEGAL_recursion(i), Int(1))
+    i = pt.ScratchVar(pt.TealType.uint64)
+    return pt.Seq(i.store(pt.Int(15)), ILLEGAL_recursion(i), pt.Int(1))
 
 
 USER_GUIDE_SNIPPETS_COPACETIC = [
@@ -65,7 +64,7 @@ def test_user_guide_snippets_good(snippet):
 
 USER_GUIDE_SNIPPETS_ERRORING = {
     user_guide_snippet_ILLEGAL_recursion: (
-        TealInputError,
+        pt.TealInputError,
         "ScratchVar arguments not allowed in recursive subroutines, but a recursive call-path was detected: ILLEGAL_recursion()-->ILLEGAL_recursion()",
     )
 }
@@ -80,6 +79,6 @@ def test_user_guide_snippets_bad(snippet_etype_e):
         f"Test case function=[{snippet.__name__}]. Expecting error of type {etype} with message <{e}>"
     )
     with pytest.raises(etype) as tie:
-        compileTeal(snippet(), mode=Mode.Application, version=6)
+        pt.compileTeal(snippet(), mode=pt.Mode.Application, version=6)
 
     assert e in str(tie)