Course: Pythonista to Python Master - Part 4 Restful Web Services with Python

Flask-RESTful is the extension for Flask that contains functions and support you'll use to develop REST APIs. Python developers will enjoy the ease and speed of a minimal set up before moving on to explore Flask-RESTful's built-in template library. Using templates as a jumping off point during development is a great way to quickly and easily develop REST APIs, and it has the additional benefit of guiding you to consistently follow API development best practices. In this course, you'll learn to set up your environment to build a RESTful API server. You'll install the Flask-RESTful libraries on Windows and macOS and you'll also work with the CURL command-line utility to make API calls. Next you'll implement a simple API server that responds to HTTP GET requests and then how to configure responses for GET, POST, PUT, and DELETE requests. Moving on, you'll configure your API server to accept parameters as part of the URL path and send data to your server using the request body in POST requests. Upon finishing this course, you'll be able to configure a simple API server using Flask-RESTful to respond to your HTTP requests.

A major benefit when building REST APIs in Flask-RESTful, is unlimited access to use the built-in request parser any time you want to parse and validate input arguments to your API server. Python developers will find the flexibility and extensibility of Flask-RESTful very useful. In this course, you'll learn to effectively use a request parser object to parse and extract input arguments from user requests. You'll validate input arguments using the right configuration before setting up custom help messages for the parser arguments. Next, you'll examine how your request parser can look beyond the request body - in the query string, cookies, and other locations, for input arguments. You'll explore how to inherit from an existing parser object and how to modify a parser to suit your needs. Finally, you'll investigate how to make errors returned by the parser more user-friendly by choosing to bundle them together to return as a group in a JSON response.

Learn more about Flask-RESTful, which connects to the ORM libraries you use to connect to your database. You'll set up APIs to perform create, read, update, and delete (CRUD) operations. You'll then implement APIs using an in-memory dictionary before integrating them with a MySQL database back end. You'll set up a MySQL database and work with MySQL Workbench. You'll install and use the Advanced REST Client.

This course introduces you to a breadth of features available in the Molten framework to help you build HTTP APIs. You'll begin by creating a virtual environment, installing Molten and various other libraries such as Pytest to test out your Molten apps, and installing Gunicorn to serve your apps. You'll then move on to creating REST APIs using the Molten framework. You'll create a very basic REST API with only one route that maps to a function and the API to process an HTTP GET request. You'll also explore the use of a QueryParam object to handle query parameters passed in an HTTP request. You'll next test your Molten APIs using Pytest by writing some simple tests to ensure an HTTP 200 status code is returned when a correct request is sent to the server and an error code is returned with the response otherwise. You'll also learn how these tests can be executed and how to analyze their outputs. You'll learn about the processing of POST requests, how to ensure the validity of POST data using a Molten Schema instance, different ways to define a schema, and how to use a forward reference. You'll explore the built-in objects available in the Molten framework and how to pass in a plain Python dictionary containing settings for an app. Finally, you'll see how settings can be saved in an external JSON file and then imported into a Molten app and how to load settings defined within a TOML file.

This course covers the use of features in the Molten framework to make your HTTP APIs meaningful and easy to use and test. You'll begin by connecting your Molten application to a SQLite database, including the creation of a cursor to work with the database. You'll then wire up your app so that all the data sent in using POST requests to a specific route is written out to the database. You'll also define handlers for GET requests for that same data by reading from the database. Next, you'll then look at adding middleware into your app and set this middleware to check request headers for the authorization to invoke requests. You'll also tweak the middleware to distinguish between certain types of requests so that authorization is only required for some of them. You'll also see how you can dynamically generate documentation for your Molten application using the OpenAPIHandler. You'll explore how you can use the OpenAPIUIHandler to produce a Swagger UI, which can be used by developers to test the application and also by users to figure out exactly how to use your APIs. Finally, you'll learn how you can serve images to clients using Molten, including attaching a local file to a Response object and returning it to the client.

Django, an advanced Python web framework, allows quick development of secure and sustainable websites. In this course, you'll discover how Django web requests work, which will involve using HTTP protocols, formatting content as HTML pages, using web servers to process requests, and distinguishing between static and dynamic websites. Moving on, you'll identify the steps involved in creating websites, which include reusing HTML elements over multiple pages on a website, customizing user experience by maintaining sessions, and querying databases for content. Next, you'll explore the features provided by web frameworks, particularly Django, that support and greatly simplify all these operations. You'll also investigate the use of Django templates. Finally, you'll become familiar with the migration process within Django and the use of the Django Model class to create subclasses that map to tables in a relational database.

The Django web framework simplifies creating websites and REST APIs through a wide variety of built-in features. In this course, you'll learn how to use some of these built-in features to create websites and apps. You'll start by installing the Django web framework inside a virtual environment. You'll then explore Django's out-of-the-box features, including the project structure, the shell, and the built-in admin app. Next, you'll build a Hello World website using a custom Django app. This process includes defining a URL that maps to a view, which then returns an HTTP response that can be viewed from a browser. Moving on, you'll explore the use of Django templates, which includes the use of base and derived templates. Finally, you'll work with the built-in admin app, examining how to administer users and groups and assign permissions.

Creating websites and REST APIs is simplified through Django's built-in features. In this course, you'll learn how to use some of these features to build highly-performant websites and apps. You'll begin by examining how Django models are defined, migrated to a linked database, and registered with the built-in admin app. You'll then move on to using the Django ModelForm base class, which allows you to create a web page to create instances of your Django model. You'll then explore how to create a sign-in page for your Django website users and present signed-in users with a different view of the site. Finally, you'll cover how users can be allowed to sign out of your website.

The robust websites and apps produced using Django suggest a much more complicated framework than is used. In this course, you'll build on your existing Django knowledge to perform some Django template language operations. You'll start this course by performing various query operations on your Django model instances from the Python shell. You'll also use the Django admin website to work with your models. You'll implement class-based views in Django, first using the ListView class to view multiple instances of a model before using the DetailView class to view individual records. Moving along, you'll use CreateView and UpdateView to generate and modify instances and implement a DeleteView for their easy removal. You'll round off this course by briefly exploring how to improve the aesthetics of your class-based views by incorporating HTML elements, such as tables, in their corresponding templates.

A Django project is simply a web application consisting of one or more apps within it. Django's features ensure you can link multiple related project apps, create apps that accept and store user information, and trigger actions, such as sending emails. In this course, you'll practice carrying out these tasks in Django. You'll start by illustrating how images are incorporated within Django models, displayed on a web page, and stored on a file system while their paths are saved in the database. Next, you'll implement multiple separate but related apps within a Django project. Finally, you'll learn how to ensure a user's selection from a set of checkboxes is stored by your model and work with a user's email credentials to send them an email.

Among Django's many out-of-the-box tools is the REST Framework package, which includes libraries to build APIs. In this course, you'll install and work with this package to allow users to access and submit data to your web application. You'll start by defining a simple model whose instances can be accessed and manipulated using REST APIs. To make this happen, you'll use the built-in Django ModelSerializer class. You'll then wire up your Django REST API to return a list of JSON values from your Django model whenever a GET request is sent. You'll also use the Django REST framework's built-in web UI and the curl command-line utility to send POST requests to submit data to the server and use it to create model instances. Moving on, you'll briefly examine the use of HEAD and OPTION requests before wrapping up with a short exploration of PUT and DELETE requests.

In this practice lab, learners will be presented with a series of exercises to practice developing in Python. Exercises include tasks such as installing Flask-RESTful, using Flask RESTful request parser, performing operations on a table in a database from a web server, and creating a virtual environment to run Molten. Learners will also practice creating views using Django templates, installing Django in a virutal Python environment, creating a Django model, and adding and accessing images in a Django model. Learners can also use the environment as an open sandbox. No installation or configuration is required, so you can gain immediate hands-on experience. Create new files or upload your own from a storage location of your choice, such as GitHub, and you can practice coding right away! You can even download a copy of your work when you're done. Whether you're looking to dive into the code presented within our courses or you want to work on your own coding projects, this lab environment will provide you with everything you need. So, go ahead and start coding today! See below for a complete list of available software. - Python 3.7 - Python 2.7 - Tkinter GUI - Python 3 libraries: - Django - Flask - Flask-Migrate - Flask-SQLAlchemy - Flask-WTF - beautifulsoup4 - selenium - Python 2/3 libraries: - ipython - pytest - testbook - Pip 2 and 3 - Node.js - npm - Git - Vim editor - Standard Python libraries This lab is part of the Building Restful Web Services with Python track of the Skillsoft Aspire Pythonista to Python Master Journey.

Final Exam: Building Restful Web Services with Python will test your knowledge and application of the topics presented throughout the Building Restful Web Services with Python track of the Skillsoft Aspire Pythonista to Python Master Journey.