Web Service calls and operations support

import aiohttp
session = aiohttp.ClientSession()
res = session.get('https://api.github.com/events')

from aiohttp import web
async def handler(request):
    return web.Response(text="Welcome in Python")
app = web.Application()
app.router.add_get('/index', handler)
web.run_app(app)

from bottle import Bottle
app = Bottle()

# using get decorator
@app.get("/")
def HelloWorld():
    return {"message":"Hello World"}

# using generic route decorator
@app.route("/Goodbye",method="GET")
def Goodbye():
    return {"message":"Goodbye World"}

# routing with parameter value
@app.get("/items/<item_id:int>")
def read_item(item_id: int):
    return {"item_id":item_id}

from bottle import get,route

# using get decorator
@get("/")
def HelloWorld():
    return {"message":"Hello World"}

# using generic route decorator
@route("/Goodbye",method="GET")
def Goodbye():
    return {"message":"Goodbye World"}

# routing with parameter value
@get("/items/<item_id:int>")
def read_item(item_id: int):
    return {"item_id":item_id}

from bottle import post, put, delete

@post("/users/")
async def create_User(user):
    return user

@put("/users/")
async def update_User(user):
    return user

@delete("/users/")
async def remove_User(user):
    return user

import cherrypy

class StringGenerator(object):
    @cherrypy.expose
    def index(self):
        return "Hello world!"

mysite
└── mysite
    ├── db.sqlite3
    ├── manage.py
    ├── mysite
    │   ├── __init__.py
    │   ├── asgi.py
    │   ├── settings.py
    │   ├── urls.py
    │   ├── views.py
    │   └── wsgi.py
    └── polls
        ├── __init__.py
        ├── admin.py
        ├── apps.py
        ├── migrations
        │   ├── 0001_initial.py
        │   ├── __init__.py
        ├── models.py
        ├── templates
        │   └── polls
        │       └── index.html
        ├── tests.py
        ├── urls.py
        └── views.py

from django.http import HttpResponse
from django.views.decorators.http import require_GET
from django.views.generic import TemplateView

@require_GET
def standard_index(request):
    return HttpResponse("Hello, world. You're at the root index.")

class MyView(TemplateView):

    template_name = "about.html"

    def post(self,request, params):
        return HttpResponse("Hello, world, you request a POST with params %s." %params)

from django.contrib import admin
from django.urls import include, path,re_path,url
from . import views

urlpatterns = [
    re_path('^$', views.standard_index,name='root index'),
    url("^about/$", views.MyView.as_view(),name="about"),
    path('polls/', include('polls.urls')),
]

from django.template import loader
from django.http import HttpResponse
from .models import Question

def index(request):
    latest_question_list = Question.objects.order_by('-pub_date')[:5]
    template = loader.get_template('polls/index.html')
    context = {'latest_question_list': latest_question_list, }
    return HttpResponse(template.render(context, request))

class Polls:
    def detail(request, question_id):
        return HttpResponse("You're looking at question %s." % question_id)
    
    def results(request, question_id):
        response = "You're looking at the results of question %s."
        return HttpResponse(response % question_id)
    
    def vote(request, question_id):
        return HttpResponse("You're voting on question %s." % question_id)

from django.urls import path
from .views import index,Polls

urlpatterns = [
    # ex: /polls/
    path('', index, name='index'),
    # ex: /polls/5/
    path('<int:question_id>/', Polls.detail, name='detail'),
    # ex: /polls/5/results/
    path('<int:question_id>/results/', Polls.results, name='results'),
    # ex: /polls/5/vote/
    path('<int:question_id>/vote/', Polls.vote, name='vote'),
]

importfalcon
 
app=falcon.App()
 
class GetResource():
    def on_get():
        print('on_get function')
 
def sink_method(resp,kwargs):
    resp.body="Sink"
    pass
 
app.add_route('this/is/the/way', GetResource())
app.add_sink(sink_method, prefix='/that') # get, post, put & delete routes will be created and linked to sink_method
app.add_sink(sink_method, prefix='/this') # no routes created because Url overlaps another route

import falcon
app=falcon.App()
 
class PrefixResource(object):
 
    def on_get(self, req, resp):
         pass
 
    def on_get_foo(self, req, resp):
         pass
 
    def on_post_foo(self, req, resp):
        pass
 
    def on_delete_bar(self, req, resp):
        pass
 
app.add_route('get/without/prefix', PrefixResource())
app.add_route('get/and/post/prefix/foo', PrefixResource(), suffix='foo')
app.add_route('delete/prefix/bar', PrefixResource(), suffix='bar')

from fastapi import FastAPI
 
app1 = FastAPI()
app2 = FastAPI(root_path="/tata")
 
# regular routing 2 examples with FastAPI
# with instance app1
 
@app1.get("/")
async def HelloWorld_app1():
    return {"message": "Hello World"}
 
@app1.get("/Me")
async def HelloMe_app1():
    return {"message": "Mika"}
 
# with app2
@app2.get("/")
async def HelloWorld_app2():
    return {"message": "Hello World"}
 
@app2.get("/Me")
async def HelloMe_app2():
    return {"message": "Mika"}

from fastapi import APIRouter
 
routeur1 = APIRouter()
routeur2 = APIRouter(prefix="/tonton")
 
# regular routing 2 examples with APIRouter
# with routeur1
@routeur1.get("/")
async def HelloWorld_routeur1():
    return {"message": "Hello World"}
 
@routeur1.get("/Me")
async def HelloMe_router1():
    return {"message": "Mika"}
 
# with routeur2
@routeur2.get("/")
async def HelloWorld_router2():
    return {"message": "Hello World"}
 
@routeur2.get("/Me")
async def HelloMe_router2():
    return {"message": "Mika"}

from fastapi import FastAPI
 
app = FastAPI()
 
# routing with parameter value
@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}
 
@app.get("/user/{name}")
async def read_user(name:str):
    return {"name": name}

from fastapi import FastAPI
 
app = FastAPI()
 
@app.post("/users/")
async def create_User(user):
    return user

@app.put("/users/")
async def update_User(user):
    return user
 
@app.delete("/users/")
async def remove_User(user):
    return user

from flask import Flask
app = Flask(__name__)
 
@app.route('/')
def f():
    return 'hello world!'
 
@app.route('/upload', methods=['POST', 'PUT'])
def upload_file()
    if request.method == 'POST':
            pass
    # ...

from flask import Flask
app = Flask(__name__)
 
@app.route('/user/<username>')
def show_user_profile(username):
    return 'User %s' % username

from flask import Flask
app = Flask(__name__)    
 
def index():
    pass
    
app.add_url_rule('/', 'index')

from flask.views import MethodView

class InformationAPI(MethodView):

    def get(self):
        information = Information.from_data(request.data)
        ...

app.add_url_rule('/<info>/informations/', view_func=InformationAPI.as_view('informations'))

from httplib import HTTPConnection
def f():
    conn = HTTPConnection("www.python.org")
    conn.request("GET", "/index.html")

from http.client import HTTPConnection
def f():
    conn = HTTPConnection("www.python.org")
    conn.request("GET", "/index.html")

import httplib2
h = httplib2.Http(".cache")
(resp, content) = h.request("https://api.github.com/events")

from nameko.web.handlers import http
 
class HttpService:
    name = "http_service"
 
    @http(method='GET', url='/get/<int:value>')
    def get_methods(self, request, value):
        return 'value={}'.format(value)
 
    @http('POST', '/post')
    def do_post(self, request):
        return u"received: {}".format(request.get_data(as_text=True))
 
    @http('GET,PUT,POST,DELETE,OPTIONS', '/multi')
    def do_multi(self, request):
        return request.method

from nameko.web.handlers import http
from werkzeug.wrappers import Response
 
class Service:
    name = "advanced_http_service"
 
 
    def get_something(self):
        return "Hello World!"
 
    @http('GET,POST','/')
    def index(self,request):
        if request.method =="GET":
            return self.get_something()
        else:
            return request.get_data(as_text=True)+"\n"
 
    @http('GET', '/privileged')
    def forbidden(self, request):
        return 403, "Forbidden"
 
    @http('GET', '/headers')
    def redirect(self, request):
        return 201, {'Location': 'https://www.example.com/widget/1'}, ""
 
    @http('GET', '/custom')
    def custom(self, request):
        return Response("payload")

from pyramid.view import view_config
from wsgiref.simple_server import make_server # wsgi: web server gateway interface
from pyramid.config import Configurator
from pyramid.response import Response

def handler_a(request):
    return Response("Hello world from handler_a")

def handler_b(request):
    return Response("Hello world from handler_b")

if __name__ == '__main__':
    config = Configurator()
    with config.route_prefix_context('main'): # can also do ('main')
        config.add_route(name='a', pattern='home')
    config.add_route(name='b', pattern='home')
    config.add_view(view=handler_a, route_name='a', request_method=('GET', 'DELETE'))
    config.add_view(view=handler_b, route_name='b', request_method=('GET', 'POST'))
    app = config.make_wsgi_app()
    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

from wsgiref.simple_server import make_server # wsgi: web server gateway interface
from pyramid.view import view_defaults
from pyramid.view import view_config
from pyramid.config import Configurator
from pyramid.response import Response

@view_defaults(route_name='rest')
class RESTView(object):
    def __init__(self, request):
        self.request = request

    @view_config()
    def handler1(self):
        return Response('default')

    @view_config(request_method='POST')
    def handler2(self):
        return Response('post')

    @view_config(request_method='DELETE')
    def handler3(self):
        return Response('delete')

if __name__ == '__main__':
    with Configurator() as config:
        config.add_route('rest', '/')
        config.scan()
        app = config.make_wsgi_app()
    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

from wsgiref.simple_server import make_server # wsgi: web server gateway interface
from pyramid.config import Configurator
from pyramid.response import Response
from pyramid.view import view_config

@view_config(route_name="hello", request_method=("GET", "DELETE"))
class ViewHello():
    def __init__(self, request) -> None:
        self.request = request

    def __call__(self):
        return Response("Hello world")

if __name__ == '__main__':
    with Configurator() as configurator:
        configurator.add_route(name="hello", pattern="hello", request_method="GET")
        configurator.scan()
        app = configurator.make_wsgi_app()
    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.view import view_config
from pyramid.response import Response

@view_config(permission='view', route_name='main', renderer='templates/main.pt') 
def main_view(request):
    return Response("main get")

@view_config(permission='view', route_name='about', renderer='templates/about.pt')
def about_view(request):
    return Response("about get")

if __name__ == "__main__":
    with Configurator() as config:
        config.include("route", route_prefix="home")
        config.scan()
        app = config.make_wsgi_app()

    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

def includeme(a):
    a.add_route('about', 'about')
    a.add_route('main', '')

def add_pyramid_routes(a):
    a.add_route('idea', '/ideas/{idea_id}')
    a.add_route('user', '/users/{username}')
    a.add_route('tag', '/tags/{tag_name}')
    a.add_route('idea_add', '/idea_add')
    a.add_route('idea_vote', '/idea_vote')
    a.add_route('register', '/register')
    a.add_route('login', '/login')
    a.add_route('logout', '/logout')
    a.add_route('about', '/about')
    a.add_route('main', '/')

from wsgiref.simple_server import make_server
from pyramid.config import Configurator

if __name__ == "__main__":
    with Configurator() as config:
        config.include("routes.add_pyramid_routes")
        config.scan("views")
        app = config.make_wsgi_app()
 
    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

from pyramid.response import Response
from pyramid.view import view_config
 
@view_config(permission='view', route_name='main', renderer='templates/main.pt')
def main_view(request):
    return Response("main get")
 
@view_config(permission='post', route_name='idea_vote')
def idea_vote(request):
    return Response("idea_vote get")
 
@view_config(permission='view', route_name='register', renderer='templates/user_add.pt')
def user_add(request):
    return Response("register get")
 
@view_config(permission='post', route_name='idea_add', renderer='templates/idea_add.pt')
def idea_add(request):
    return Response("idea_add get")
 
@view_config(permission='view', route_name='user', renderer='templates/user.pt')
def user_view(request):
    return Response("user get")
 
@view_config(permission='view', route_name='idea', renderer='templates/idea.pt')
def idea_view(request):
    return Response("idea get")
 
@view_config(permission='view', route_name='tag', renderer='templates/tag.pt')
def tag_view(request):
    return Response("tag get")
 
@view_config(permission='view', route_name='about', renderer='templates/about.pt')
def about_view(request):
    return Response("about get")
 
@view_config(permission='view', route_name='login')
def login_view(request):
    return Response("login get")
 
@view_config(permission='post', route_name='logout')
def logout_view(request):
    return Response("logout get")

import requests
r = requests.get('https://api.github.com/events')

from sanic import Sanic
from sanic.response import json

app = Sanic(__name__)

# using get decorator
@app.get("/")
async def HelloWorld(request):
    return json({"message":"Hello World"})

# using generic route decorator
@app.route("/Goodbye")
async def Goodbye(request):
    return json({"message":"Goodbye World"})


# routing with parameter value
@app.get("/items/<item_id:int>")
async def read_item(request,item_id: int):
    return json({"item_id":item_id})


# using add_route method.
async def HelloMe(request):
    return json({"message":"Hello Me"})

app.add_route(HelloMe,"/Me")

from sanic import Sanic

app = Sanic(__name__)

@app.post("/users/")
async def create_User(user):
    return user

@app.put("/users/")
async def update_User(user):
    return user

@app.delete("/users/")
async def remove_User(user):
    return user

from tornado.web import Application, RequestHandler

class MainHandler(RequestHandler):
    def get(self):
        self.write("Hello, world")
    def post(self):
        self.write("Hello, CAST")

if __name__ == "__main__":
    application = Application([
        ("/", MainHandler)
    ])

import tornado.web

class BaseHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Get base")

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Get main")
    def post(self):
        self.write("Post main")
    def put(self):
        self.write("Put main")
    def delete(self):
        self.write("Delete main")
    def display(self):
        self.write("You shall not pass!")

class StoryHandler(tornado.web.RequestHandler):
    def set(self, story_id):
        self.write("this is story %s" % story_id)
    def get(self, story_id):
        self.write("this is story %s" % story_id)

init_rules = [("/", BaseHandler),]
rules = [(r"/main/", MainHandler), (r"/main/story/([0-9]+)", StoryHandler)]

if __name__ == "__main__":
    application = tornado.web.Application(init_rules)
    application.add_handlers(".*", rules)

import urllib.request
with urllib.request.urlopen('http://python.org/') as response:
   html = response.read()

import urllib2

req = urllib2.Request('http://python.org/')
response = urllib2.urlopen(req)
the_page = response.read()

import urllib2
import urllib

values = {'name' : 'Michael Foord',
          'location' : 'Northampton',
          'language' : 'Python' }

data = urllib.urlencode(values)

req = urllib2.Request('http://python.org/', data)
response = urllib2.urlopen(req)
the_page = response.read()

# using PoolManager
import urllib3
http = urllib3.PoolManager()
r = http.request('GET', 'http://httpbin.org/robots.txt')

# using HTTPConnectionPool
import urllib3
pool = urllib3.HTTPConnectionPool()
r = pool.request('GET', 'http://httpbin.org/robots.txt')

from gluon.tools import fetch
def m(self):
    page = fetch('http://www.google.com/')