Small Introduction About GraphQL?

What is GraphQL?

GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.

GraphQL queries access not just the properties of one resource but also smoothly follow references between them. While typical REST APIs require loading from multiple URLs, GraphQL APIs get all the data your app needs in a single request. Apps using GraphQL can be quick even on slow mobile network connections.

GraphQL APIs are organized in terms of types and fields, not endpoints. Access the full capabilities of your data from a single endpoint. GraphQL uses types to ensure Apps only ask for what’s possible and provide clear and helpful errors. Apps can use types to avoid writing manual parsing code.

GraphQL creates a uniform API across your entire application without being limited by a specific storage engine. Write GraphQL APIs that leverage your existing data and code with GraphQL engines available in many languages. You provide functions for each field in the type system, and GraphQL calls them with optimal concurrency.

Video for GraphQL

Small Overview About GraphQL?

What is GraphQL?

GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.

GraphQL is a query language created by Facebook in 2012 which provides a common interface between the client and the server for data fetching and manipulations.

The client asks for various data from the GraphQL server via queries. The response format is described in the query and defined by the client instead of the server: they are called client‐specified queries.

The structure of the data is not hardcoded as in traditional REST APIs - this makes retrieving data from the server more efficient for the client.

GraphQL is a different way of structuring the contract between client and server. The servers publish a set of rules specific to an application. GraphQL then supplies the language to query your data for the correct answer, within the constraints of those rules.

Video for GraphQL

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

Small Introduction about aiohttp in python?

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

Small Introduction About Seaborn?

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

Small Introduction about mlpack?

What is Mlpack Library?

mlpack is a C++ machine learning library with emphasis on scalability, speed, and ease-of-use. Its aim is to make machine learning possible for novice users by means of a simple, consistent API, while simultaneously exploiting C++ language features to provide maximum performance and maximum flexibility for expert users.

This is done by providing a set of command-line executables which can be used as black boxes, and a modular C++ API for expert users and researchers to easily make changes to the internals of the algorithms.

As a result of this approach, mlpack outperforms competing machine learning libraries by large margins; see the BigLearning workshop paper and the benchmarks for details.

mlpack is developed by contributors from around the world. It is released free of charge, under the 3-clause BSD License (more information). (Versions older than 1.0.12 were released under the GNU Lesser General Public License: LGPL, version 3.)

mlpack was originally presented at the BigLearning workshop of NIPS 2011 [pdf] and later published in the Journal of Machine Learning Research [pdf], with version 3 being published in the Journal of Open Source Software [pdf]. Please cite mlpack in your work using this citation.

mlpack bindings for R are provided by the RcppMLPACK project.

Currently mlpack supports the following algorithms:

Collaborative Filtering
Decision stumps (one-level decision trees)
Density Estimation Trees
Euclidean Minimum Spanning Trees
Gaussian Mixture Models (GMMs)
Hidden Markov Models (HMMs)
Kernel Principal Component Analysis (KPCA)
K-Means Clustering
Least-Angle Regression (LARS/LASSO)
Linear Regression
Local Coordinate Coding
Locality-Sensitive Hashing (LSH)
Logistic regression
Max-Kernel Search
Naive Bayes Classifier
Nearest neighbor search with dual-tree algorithms
Neighbourhood Components Analysis (NCA)
Non-negative Matrix Factorization (NMF)
Principal Components Analysis (PCA)
Independent component analysis (ICA)
Rank-Approximate Nearest Neighbor (RANN)
Simple Least-Squares Linear Regression (and Ridge Regression)
Sparse Coding, Sparse dictionary learning

For more detail visit here - http://mlpack.org/docs.html

Video for Mlpack

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

Small Introduction About PyShark?

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

Small Introduction about FastText?

What is FastText?

FastText is an open-source, free, lightweight library that allows users to learn text representations and text classifiers. It works on standard, generic hardware. Models can later be reduced in size to even fit on mobile devices.
FastText builds on modern Mac OS and Linux distributions. Since it uses C++11 features, it requires a compiler with good C++11 support.

Steps for Installing

- git clone https://github.com/facebookresearch/fastText.git
- cd fastText
- make

Text classification is a core problem to many applications, like spam detection, sentiment analysis or smart replies. In this tutorial, we describe how to build a text classifier with the fastText tool.

What is text classification?
The goal of text classification is to assign documents (such as emails, posts, text messages, product reviews, etc...) to one or multiple categories. Such categories can be review scores, spam v.s. non-spam, or the language in which the document was typed.

Nowadays, the dominant approach to build such classifiers is machine learning, that is learning classification rules from examples. In order to build such classifiers, we need labeled data, which consists of documents and their corresponding categories (or tags, or labels).

Video for FastText

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

Small Introduction about Django CMS?

What is Django CMS?

Django CMS is a modern web publishing platform built with Django, the web application framework “for perfectionists with deadlines”.

django CMS offers out-of-the-box support for the common features you’d expect from a CMS, but can also be easily customized and extended by developers to create a site that is tailored to their precise needs.

Integrate Django applications painlessly; build sophisticated sites with easy-to-use tools.

$ pip install --upgrade virtualenv
$ virtualenv env
$ source env/bin/activate
(env) $ pip install djangocms-installer
(env) $ djangocms mysite

Features

Frontend-editing
Reusable plugins
Flexible Plugin Architecture
Search Engine Optimization
Editorial workflow
Permission Management
Versioning
Multisites
Multilanguage
Applications (Apps)
Media Asset Manager (MAM)

Video for Django CMS

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

Small Introduction About GraphQL?

References

Your comment on this post:

Related Articles