top button
Flag Notify
    Connect to us
      Site Registration

Site Registration

About TurboGears ?

0 votes
204 views

What is TurboGears ?

TurboGears is a Python web framework based on the ObjectDispatch paradigm, it is meant to make possible to write both small and concise applications in Minimal mode or complex application in Full Stack mode.

TurboGears is a Rapid Web Application development with a slightly different focus. Sure we can scale down to solve the simple problems, and create single database backed dynamic web pages.

TurboGears 2 is designed to be a web-application framework suitable for solving complex industrial strength problems.

TG2 has a transaction manager to help with multi-dababase deployments, SQLAlchemy provides one of the most robust object relational management systems available in any language, and we’ve seen it concur complex issues with legacy databases, sharding, master-slave replication, and multiple integration databases.

Features

  • Starts as a microframework and scales up to a fullstack solution
  • Code that is as natural as writing a function
  • A powerful and flexible Object Relational Mapper (ORM) with real multi-database support
  • Support for Horizontal data partitioning (aka, sharding)
  • A new widget system to make building AJAX heavy apps easier
  • Support for multiple data-exchange formats
  • Built in extensibility Pluggable Applications and standard WSGI components
  • Designer friendly template system great for programmers

 

Example Code - Hello World
from tg import expose, TGController, AppConfig

class RootController(TGController):
    @expose()
    def index(self):
        return 'Hello World'

Video for TurboGears 

posted Dec 20, 2016 by Manish Tiwari

  Promote This Article
Facebook Share Button Twitter Share Button LinkedIn Share Button


Related Articles

What is aiohttp?
Asynchronous HTTP client/server framework for asyncio and Python 

Features:

  • Supports both client and server side of HTTP protocol.
  • Supports both client and server Web-Sockets out-of-the-box and avoids Callback Hell.
  • Provides Web-server with middlewares and pluggable routing.

Commands

pip install aiohttp

You may want to install optional cchardet library as faster replacement for chardet:

pip install cchardet

For speeding up DNS resolving by client API you may install aiodns as well. This option is highly recommended:

pip install aiodns

Example

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, 'http://python.org')
        print(html)

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

Video for aiohttp

https://www.youtube.com/watch?v=Z784Mwm4VBg

 

 

READ MORE

What is Mezzanine?

Mezzanine is a powerful, consistent, and flexible content management platform. Built using the Django framework, Mezzanine provides a simple yet highly extensible architecture that encourages diving in and hacking on the code. Mezzanine is BSD licensed and supported by a diverse and active community.

In some ways, Mezzanine resembles tools such as Wordpress, providing an intuitive interface for managing pages, blog posts, form data, store products, and other types of content. But Mezzanine is also different. Unlike many other platforms that make extensive use of modules or reusable applications, Mezzanine provides most of its functionality by default. This approach yields a more integrated and efficient platform.

Features

  • Hierarchical page navigation
  • Save as draft and preview on site
  • Scheduled publishing
  • Drag-and-drop page ordering
  • WYSIWYG editing
  • In-line page editing
  • Drag-and-drop HTML5 forms builder with CSV export
  • SEO friendly URLs and metadata
  • E-commerce / Shopping cart module (Cartridge)
  • Configurable dashboard widgets
  • Blog engine
  • Tagging
  • Free Themes, and a Premium Themes Marketplace
  • User accounts and profiles with email verification
  • Translated to over 35 languages
  • Sharing via Facebook or Twitter
  • Multi-lingual sites
  • Custom templates per page or blog post
  • Twitter Bootstrap integration
  • API for custom content types
  • Search engine and API

Mezzanine is an open source project managed using both the Git and Mercurial version control systems.

Video for Mezzanine blogging

https://www.youtube.com/watch?v=3I5nrcsy7RI

READ MORE

What is Seaborn?
Seaborn is a Python data visualization library based on matplotlib. It provides a high-level interface for drawing attractive and informative statistical graphics.

Features

  • A dataset-oriented API for examining relationships between multiple variables
  • Specialized support for using categorical variables to show observations or aggregate statistics
  • Options for visualizing univariate or bivariate distributions and for comparing them between subsets of data
  • Automatic estimation and plotting of linear regression models for different kinds dependent variables
  • Convenient views onto the overall structure of complex datasets
  • High-level abstractions for structuring multi-plot grids that let you easily build complex visualizations
  • Concise control over matplotlib figure styling with several built-in themes
  • Tools for choosing color palettes that faithfully reveal patterns in your data

Seaborn aims to make visualization a central part of exploring and understanding data. Its dataset-oriented plotting functions operate on dataframes and arrays containing whole datasets and internally perform the necessary semantic mapping and statistical aggregation to produce informative plots.

Example Code

import seaborn as sns
sns.set()
tips = sns.load_dataset("tips")
sns.relplot(x="total_bill", y="tip", col="time",
            hue="smoker", style="smoker", size="size",
            data=tips);

Video for Seaborn
https://www.youtube.com/watch?v=eMkEL7gdVV0

READ MORE

What is Redmine?
Redmine is a flexible project management web application. Written using the Ruby on Rails framework, it is cross-platform and cross-database.

Redmine is open source and released under the terms of the GNU General Public License v2 (GPL).

It is a cross-platform, cross-database, and open source tool that also has issue-tracking features. Users can manage multiple projects and subprojects, and have access to many planning, tracking, and documenting features available from similar commercial products. 

Redmine has a news area where members can publish news items. It allows the creation of documents, such as user documentation or technical documentation, which can be downloaded by others. A Files module is a table that lists all uploaded files and its details. 

Users can easily create project wikis with the help of a toolbar. Other features include custom fields for creating additional information, and a Repository to view a given revision and the latest commits. The software can be configured to receive emails for issue creation and comments. It also supports particular versions of different databases, such as MySQL, PostgreSQL, MS SQL Server, and SQLite. API and plug-ins are also available.

Features

  • Multiple projects support
  • Flexible role based access control
  • Flexible issue tracking system
  • Gantt chart and calendar
  • News, documents & files management
  • Feeds & email notifications
  • Per project wiki
  • Per project forums
  • Time tracking
  • Custom fields for issues, time-entries, projects and users
  • SCM integration (SVN, CVS, Git, Mercurial and Bazaar)
  • Issue creation via email
  • Multiple LDAP authentication support
  • User self-registration support
  • Multilanguage support
  • Multiple databases support

Video for Redmine Introduction

https://www.youtube.com/watch?v=sAobJ1kmyqA

 

READ MORE

What is WSGI?

WSGI is the Web Server Gateway Interface

It is a specification that describes how a web server communicates with web applications, and how web applications can be chained together to process one request.

WSGI is a specification, laid out in PEP 333, for a standardized interface between Web servers and Python Web frameworks/applications.

The goal is to provide a relatively simple yet comprehensive interface capable of supporting all (or most) interactions between a Web server and a Web framework. (Think "CGI" but programmatic rather than I/O based.)

An additional goal is to support "middleware" components for pre- and post-processing of requests: think gzip, recording, proxy, load-balancing.

Main Features

- WSGI gives you flexibility

      Application developers can swap out web stack components for others. For example, a developer can switch from Green Unicorn to uWSGI without modifying the application or framework that implements WSGI. From PEP 3333:

- WSGI servers promote scaling

    Serving thousands of requests for dynamic content at once is the domain of WSGI servers, not frameworks. WSGI servers handle processing requests from the web server and deciding how to communicate those requests to an application framework's process. The segregation of responsibilities is important for efficiently scaling web traffic.

Video for WSGI 

https://www.youtube.com/watch?v=OMkOQFoUFZg

READ MORE

What is Statsmodels ?

Statsmodels is a Python package that allows users to explore data, estimate statistical models, and perform statistical tests. Statsmodels is built on top of the numerical libraries NumPy and SciPy, integrates with Pandas for data handling and uses Patsy for an R-like formula interface.

Statsmodels is part of the scientific Python stack that is oriented towards data analysis, data science and statistics. Statsmodels is built on top of the numerical libraries NumPy and SciPy, integrates with Pandas for data handling and uses Patsy[3] for an R-like formula interface. Graphical functions are based on the Matplotlib library. Statsmodels provides the statistical backend for other Python libraries. Statmodels in free software released under the Modified BSD (3-clause) license.

Features

  • Linear regression models:
  • Mixed Linear Model with mixed effects and variance components
  • GLM: Generalized linear models with support for all of the one-parameter exponential family distributions
  • Bayesian Mixed GLM for Binomial and Poisson
  • GEE: Generalized Estimating Equations for one-way clustered or longitudinal data
  • Discrete models:
  • Multivariate:
  • Nonparametric statistics: Univariate and multivariate kernel density estimators
  • Datasets: Datasets used for examples and in testing
  • Statistics: a wide range of statistical tests
  • Imputation with MICE, regression on order statistic and Gaussian imputation
  • Mediation analysis
  • Tools for reading Stata .dta files, but pandas has a more recent version
  • Table output to ascii, latex, and html
  • Miscellaneous models​

Video for Statsmodels

https://www.youtube.com/watch?v=RWRsxhUzpxk

READ MORE

What is PyShark?

PyShark is a wrapper for the Wireshark CLI interface, tshark, so all of the Wireshark decoders are available to PyShark!

Python wrapper for tshark, allowing python packet parsing using wireshark dissectors.

There are quite a few python packet parsing modules, this one is different because it doesn't actually parse any packets, it simply uses tshark's (wireshark command-line utility) ability to export XMLs to use its parsing.

This package allows parsing from a capture file or a live capture, using all wireshark dissectors you have installed. Tested on windows/linux.

Example Code for Reading a File

import pyshark
cap = pyshark.FileCapture('/tmp/mycapture.cap')
cap
>>> <FileCapture /tmp/mycapture.cap>
print cap[0]
Packet (Length: 698)
Layer ETH:
        Destination: aa:bb:cc:dd:ee:ff
        Source: 00:de:ad:be:ef:00
        Type: IP (0x0800)
Layer IP:
        Version: 4
        Header Length: 20 bytes
        Differentiated Services Field: 0x00 (DSCP 0x00: Default; ECN: 0x00: Not-ECT (Not ECN-Capable Transport))
        Total Length: 684
        Identification: 0x254f (9551)
        Flags: 0x00
        Fragment offset: 0
        Time to live: 1
        Protocol: UDP (17)
        Header checksum: 0xe148 [correct]
        Source: 192.168.0.1
        Destination: 192.168.0.2​

Video for PyShark

https://www.youtube.com/watch?v=gstHeldo61w

READ MORE
...