This site requires JavaScript to be enabled
Welcome Guest|
Recent searches
Python Production Environment (PyPE)

Python Production Environment (PyPE)

 Python Production Environment (PyPE) provides an evolution in the development environment for applications written for UT Direct

  • Python Production Environment (PyPE)

    Using the Python programming language and the Django Web framework, developers are able to write applications quickly, securely, and succinctly.

    Applications on PyPE can access both mainframe and SQL databases, providing developers the flexibility of replacing legacy applications written in webAgent or creating new applications that do not rely on the mainframe.

    Anyone with a UT EID can be granted access to work on projects. However, only users with a developer entitlement can create projects.

    Available to:Faculty and Staff
    • Supported by a suite of training classes and self-guided documentation
    • Web interface for managing access to code and deploying applications to UT Direct
    • Access to TEST, QUAL, BETA, and PROD mainframe data environments
    • Access to any external database, including ITS-hosted MySQL and Oracle databases
    • A virtual machine for quick setup of developer workstations
    • Project code drawn from repositories in the UT Austin private instance of GitHub (UTForge is being phased out).

    Python Production Environment (PyPE) is provided at no charge to develop

    Service Level Objectives

    Key Metrics

    • Availability of PyPE deployment service: 98.76%
    • Availability of the PyPE execution environment: 98.76%
    • Response time for 90% of Web requests to the PyPE execution server (<2s): 1.18s
    • Trivial (static data) requests per minute for the PyPE execution server (>4500): 5,400
    • Simple (page load) requests per minute for the PyPE execution server (>1000): 1,475
    • Availability of the PyPE Batch execution environment: 98.62%


    This document defines the service level agreement for Python Production Environment (PyPE).

    Service description

    The Production Python Environment (PyPE) service consists of a set of tools and servers that enable the development and delivery of Python and Django applications in a centrally hosted environment. Features include:

    • A Developer VM with a pre-installed set of client tools to enable desktop Python/Django development and testing on local developer workstations. These tools include Python, Java, Django, Python broker libraries, and Stunnel to secure connections from developer workstations to the broker server.
    • A deployment server to manage and deploy Python/Django projects from UT's private GitHub instance or UTForge to production and staging servers and to manage group authorizations for projects.
    • Python/Django execution environments for TEST, QUAL, BETA, and PROD. The TEST environment is only available from hosts within the domain or off-campus hosts connecting via a VPN.

    Intended users

    Python Production Environment (PyPE) can be used by staff.

    Supported computing environment

    The PyPE Developer VM is supported on any platform supported by Oracle VirtualBoxVagrant and a Git client; that includes all reasonably current versions of Windows, MacOS X, Redhat Enterprise Linux, and Ubuntu. See the respective websites for details. Due to licensing restrictions, the VM may be installed only on UT-owned equipment.

    The PyPE Deployment Server is browser-based and supports Firefox, Safari, Chrome, and Internet Explorer.

    The PyPE Service depends upon many externally provided applications, frameworks, and libraries. As these externally provided tools release new versions, their development teams will discontinue support for older versions. This in turn will have an impact on the PyPE service. The PyPE administrators will make all attempts to notify the campus user community a minimum of eight (8) months before discontinuing support for a version of the PyPE environment used at the university. In circumstances where support must be discontinued for a version because of security issues, eight months' notice of discontinued support may not be possible. Developers can specify specific tools or versions of tools for each project by including a requirements.txt in the source code for that project. 

    Given historical activity in the Python and Django communities, a lifecycle of 16 or 36 months is anticipated for a supported PyPE version. The PyPE system supports multiple concurrent versions, and allows ready deployment of an application under different versions, to facilitate the safe transition of applications to an updated environment.

    Currently supported are

    • 27.8.0 (April 2015 through March 2018)
    • 27.11.0 (April 2017 through March 2020) (Long Term Support, recommended for current engineering using Python 2)
    • 36.11.0 (April 2017 through March 2020) (Long Term Support, recommended for new development using Python 3. Migration target from 27.11.0)
    • 36.20.0 (December 2017 through March 2019) (latest stable version, note limited support period)

    Support is anticipated for

    • 36.21.0 (September 2018 through November 2019)
    • 36.22.0 (April 2019 through March 2022) (Long Term Support, recommended for all development once available)

    Technical support

    Both Tier 1 and Tier 2 technical support is available during normal business hours. Routine requests are typically addressed within one business day.

    Tier 1 and Tier 2

    Tier 1 and Tier 2 support for the PyPE Developer VM, PyPE Deployment Service, and the PyPE Execution Environments (utdirect/dpdev1/beta.dp/qual.its) is provided by ITS Systems via Service Now or directly via the list. Peer developer support can often be had via the list.

    Tier 1 and Tier 2 support for Stunnel is provided by ITS Systems via the list.

    Special Support

    Support for issues related to the operating system, storage, or network connectivity to the execution environments is provided by ITS Systems; issues must be escalated from Tier 2.


    ITS will notify customers about both scheduled and unscheduled maintenance using the ITS Services Status page of service availability and service delivery issues. Services may not be available during the maintenance periods.

    Scheduled OS maintenance for PROD and BETA environments occurs on the fourth Tuesday of each month from 5 to 7 p.m., and on TEST and QUAL on the first Tuesday of each month from 11:00 a.m. to 1 p.m. In practice these updates are applied quarterly, in January, April, July, and October, but security patching may be done on the other dates or as emergency maintenance when warranted.

    PyPE tools updates are scheduled each week, 7 to 9 a.m. Thursday. Ordinarily updates are deployed to only the TEST environment. PyPE tools updates are deployed to the QUAL, BETA, and PROD environments on the Thursday following OS maintenance of BETA and PROD as noted in the previous paragraph. Developers need not wait for updates to production, they may use the requirements.txt mechanism to take updates sooner if they see fit. Updates are made available as patches to the desktop developer VM no later than their application to the TEST environment, and usually earlier. To the maximum extent possible, installation of service, application, and security updates will be performed during scheduled maintenance.

    Unscheduled maintenance tasks that require service downtime will be announced as soon as possible on the ITS Services Status page.

    Change notification: ITS will notify customers using the ITS Services Status page and the mailing list of service availability and service delivery issues for Python Production Environment (PyPE). Communications are documented in this SLA and reviewed as part of the SLA at least annually.

    User responsibilities

    Subscribers (users) of the service and identified owners/administrators agree to be aware of and adhere to The Universityof Texas's Acceptable Use Policy.

    Application Developers agree to be responsible for the following:

    • Monitoring the list for announcements
    • Installing and configuring the developer VM.
    • Updating the developer VM at least once per quarter to acquire the latest security and other patches, or immediately if advised that a critical patch update is available.
    • Reviewing and contributing to documentation and best practices for the use of the PyPE Service.
    • Providing Tier 1 support for end users of Python/Django applications.
    • Migrating their applications to new versions of the PyPE environment as mandated by 3rd-party support expirations and informed by the PyPE Administrators

    In addition to the items listed above, departmental IT support staff agrees to:

    • Be responsible for installing, configuring, and maintaining any local development tools not supported by the PyPE Service and Toolkit.
    • Application testing. It is strongly recommended that even stable apps be tested each quarter before the OS Maintenance on the fourth Thursday.