API-ს დაწერა პითონში (Flask-ით და RapidAPI-ით)

თუ ამ სტატიას კითხულობთ, ალბათ უკვე იცნობთ იმ შესაძლებლობებს, რომლებიც იხსნება API-ს (აპლიკაციის პროგრამირების ინტერფეისი) გამოყენებისას.

თქვენს აპლიკაციაში მრავალი საჯარო API-დან ერთის დამატებით, შეგიძლიათ გააფართოვოთ ამ აპლიკაციის ფუნქციონირება ან შეავსოთ იგი საჭირო მონაცემებით. მაგრამ რა მოხდება, თუ თქვენ შექმენით უნიკალური ფუნქცია, რომელიც გსურთ გაუზიაროთ საზოგადოებას?

პასუხი მარტივია: გჭირდებათ შექმენით თქვენი საკუთარი API.

მიუხედავად იმისა, რომ ეს შეიძლება თავიდან რთულ ამოცანად ჩანდეს, სინამდვილეში საკმაოდ მარტივია. ჩვენ გაჩვენებთ, თუ როგორ უნდა გააკეთოთ ეს Python-ით.

რაც გჭირდებათ დასაწყებად

API-ს შემუშავება მოითხოვს:

• პითონი 3;
• სინჯარისთვის — მარტივი და ადვილად გამოსაყენებელი ჩარჩო ვებ აპლიკაციების შესაქმნელად;
• კოლბა-დასვენება არის Flask-ის გაფართოება, რომელიც საშუალებას გაძლევთ სწრაფად და მინიმალური კონფიგურაციით განავითაროთ REST API.

ინსტალაცია ხორციელდება ბრძანებით:

pip install flask-restful

ჩვენ გირჩევთ უფასო ინტენსიურ პროგრამირებას დამწყებთათვის:
Telegram ბოტის განვითარება C#-ში — 26–28 აგვისტო. უფასო ინტენსიური, რომელიც საშუალებას გაძლევთ გაიგოთ, თუ როგორ მუშაობს დამხმარე ბოტები, Telegram API-სთან მუშაობის მახასიათებლები და სხვა ნიუანსი. სამი საუკეთესო მონაწილე მიიღებს 30 რუბლს Skillbox-ისგან.

სანამ დაიწყე

ჩვენ ვაპირებთ RESTful API-ს შემუშავებას საბაზისო CRUID ფუნქციონირება.

ამოცანის სრულად გასაგებად, გავიგოთ ზემოთ ნახსენები ორი ტერმინი.

რა არის REST?

REST API (Representational State Transfer) არის API, რომელიც იყენებს HTTP მოთხოვნებს მონაცემთა გაცვლისთვის.

REST API-ები უნდა აკმაყოფილებდეს გარკვეულ კრიტერიუმებს:

• კლიენტი-სერვერის არქიტექტურა: კლიენტი ურთიერთქმედებს მომხმარებლის ინტერფეისთან, ხოლო სერვერი ურთიერთქმედებს backend-თან და მონაცემთა მაღაზიასთან. კლიენტი და სერვერი დამოუკიდებელია, ნებისმიერი მათგანი შეიძლება შეიცვალოს მეორისგან დამოუკიდებლად.
• მოქალაქეობის გარეშე - სერვერზე კლიენტის მონაცემები არ ინახება. სესიის მდგომარეობა ინახება კლიენტის მხარეს.
• Cacheability - კლიენტებს შეუძლიათ სერვერის პასუხების ქეშირება საერთო მუშაობის გასაუმჯობესებლად.

რა არის CRUD?

კრუდ არის პროგრამირების კონცეფცია, რომელიც აღწერს ოთხ ძირითად მოქმედებას (შექმნა, წაკითხვა, განახლება და წაშლა).

REST API-ში მოთხოვნის ტიპები და მოთხოვნის მეთოდები პასუხისმგებელია ისეთ ქმედებებზე, როგორიცაა გამოქვეყნება, მიღება, დადება, წაშლა.

ახლა, როდესაც ჩვენ განვიხილეთ ძირითადი პირობები, შეგვიძლია დავიწყოთ API-ს შექმნა.

განვითარება

მოდით შევქმნათ ციტატების საცავი ხელოვნური ინტელექტის შესახებ. AI დღესდღეობით ერთ-ერთი ყველაზე სწრაფად მზარდი ტექნოლოგიაა და Python არის პოპულარული ინსტრუმენტი AI-სთან მუშაობისთვის.

ამ API-ით Python-ის დეველოპერს შეუძლია სწრაფად გაიგოს AI-ის შესახებ და შთაგონებული იყოს ახალი მიღწევებით. თუ დეველოპერს აქვს ღირებული აზრები ამ თემაზე, მას შეეძლება მათი დამატება საცავში.

დავიწყოთ საჭირო მოდულების იმპორტით და Flask-ის დაყენებით:

from flask import Flask
from flask_restful import Api, Resource, reqparse
import random
app = Flask(__name__)
api = Api(app)

ამ ფრაგმენტში, Flask, Api და Resource არის კლასები, რომლებიც გვჭირდება.

Reqparse არის Flask-RESTful მოთხოვნის ანალიზის ინტერფეისი... თქვენ ასევე დაგჭირდებათ შემთხვევითი მოდული შემთხვევითი ციტატის საჩვენებლად.

ახლა ჩვენ შევქმნით ციტატების საცავს ხელოვნური ინტელექტის შესახებ.

რეპოს თითოეული ჩანაწერი შეიცავს:

• ციფრული ID;
• ციტატის ავტორის სახელი;
• ციტატა.

ვინაიდან ეს მხოლოდ სასწავლო მაგალითია, ჩვენ ვინახავთ ყველა ჩანაწერს პითონის სიაში. რეალურ აპლიკაციაში, ჩვენ სავარაუდოდ გამოვიყენებთ მონაცემთა ბაზას.

ai_quotes = [
    {
        "id": 0,
        "author": "Kevin Kelly",
        "quote": "The business plans of the next 10,000 startups are easy to forecast: " +
                 "Take X and add AI."
    },
    {
        "id": 1,
        "author": "Stephen Hawking",
        "quote": "The development of full artificial intelligence could " +
                 "spell the end of the human race… " +
                 "It would take off on its own, and re-design " +
                 "itself at an ever increasing rate. " +
                 "Humans, who are limited by slow biological evolution, " +
                 "couldn't compete, and would be superseded."
    },
    {
        "id": 2,
        "author": "Claude Shannon",
        "quote": "I visualize a time when we will be to robots what " +
                 "dogs are to humans, " +
                 "and I’m rooting for the machines."
    },
    {
        "id": 3,
        "author": "Elon Musk",
        "quote": "The pace of progress in artificial intelligence " +
                 "(I’m not referring to narrow AI) " +
                 "is incredibly fast. Unless you have direct " +
                 "exposure to groups like Deepmind, " +
                 "you have no idea how fast — it is growing " +
                 "at a pace close to exponential. " +
                 "The risk of something seriously dangerous " +
                 "happening is in the five-year timeframe." +
                 "10 years at most."
    },
    {
        "id": 4,
        "author": "Geoffrey Hinton",
        "quote": "I have always been convinced that the only way " +
                 "to get artificial intelligence to work " +
                 "is to do the computation in a way similar to the human brain. " +
                 "That is the goal I have been pursuing. We are making progress, " +
                 "though we still have lots to learn about " +
                 "how the brain actually works."
    },
    {
        "id": 5,
        "author": "Pedro Domingos",
        "quote": "People worry that computers will " +
                 "get too smart and take over the world, " +
                 "but the real problem is that they're too stupid " +
                 "and they've already taken over the world."
    },
    {
        "id": 6,
        "author": "Alan Turing",
        "quote": "It seems probable that once the machine thinking " +
                 "method had started, it would not take long " +
                 "to outstrip our feeble powers… " +
                 "They would be able to converse " +
                 "with each other to sharpen their wits. " +
                 "At some stage therefore, we should " +
                 "have to expect the machines to take control."
    },
    {
        "id": 7,
        "author": "Ray Kurzweil",
        "quote": "Artificial intelligence will reach " +
                 "human levels by around 2029. " +
                 "Follow that out further to, say, 2045, " +
                 "we will have multiplied the intelligence, " +
                 "the human biological machine intelligence " +
                 "of our civilization a billion-fold."
    },
    {
        "id": 8,
        "author": "Sebastian Thrun",
        "quote": "Nobody phrases it this way, but I think " +
                 "that artificial intelligence " +
                 "is almost a humanities discipline. It's really an attempt " +
                 "to understand human intelligence and human cognition."
    },
    {
        "id": 9,
        "author": "Andrew Ng",
        "quote": "We're making this analogy that AI is the new electricity." +
                 "Electricity transformed industries: agriculture, " +
                 "transportation, communication, manufacturing."
    }
]

ახლა ჩვენ უნდა შევქმნათ Quote რესურსის კლასი, რომელიც განსაზღვრავს ჩვენი API ბოლო წერტილების ოპერაციებს. კლასში უნდა გამოცხადდეს ოთხი მეთოდი: მიღება, გამოქვეყნება, დაყენება, წაშლა.

დავიწყოთ GET მეთოდით

ის საშუალებას გაძლევთ მიიღოთ კონკრეტული ციტატა მისი ID-ის მითითებით, ან შემთხვევითი ციტატა, თუ ID არ არის მითითებული.

class Quote(Resource):
    def get(self, id=0):
        if id == 0:
            return random.choice(ai_quotes), 200
        for quote in ai_quotes:
            if(quote["id"] == id):
                return quote, 200
        return "Quote not found", 404

GET მეთოდი აბრუნებს შემთხვევით ციტატას, თუ ID შეიცავს ნაგულისხმევ მნიშვნელობას, ე.ი. მეთოდის დარეკვისას ID არ იყო მითითებული.

თუ ის დაყენებულია, მაშინ მეთოდი ეძებს ბრჭყალებს შორის და პოულობს იმას, რომელიც შეიცავს მოცემულ ID-ს. თუ ვერაფერი მოიძებნა, გამოჩნდება შეტყობინება "ციტატა ვერ მოიძებნა, 404".

გახსოვდეთ, მეთოდი აბრუნებს HTTP სტატუსს 200, თუ მოთხოვნა წარმატებული იყო და 404, თუ ჩანაწერი ვერ მოიძებნა.

ახლა მოდით შევქმნათ POST მეთოდი საცავში ახალი ციტატის დასამატებლად

ის მიიღებს ყოველი ახალი ციტატის ID-ს, როგორც თქვენ აკრეფთ. გარდა ამისა, POST გამოიყენებს reqparse-ს იმ პარამეტრების გასაანალიზებლად, რომლებიც წავა მოთხოვნის სხეულში (ავტორი და ციტატის ტექსტი).

def post(self, id):
      parser = reqparse.RequestParser()
      parser.add_argument("author")
      parser.add_argument("quote")
      params = parser.parse_args()
      for quote in ai_quotes:
          if(id == quote["id"]):
              return f"Quote with id {id} already exists", 400
      quote = {
          "id": int(id),
          "author": params["author"],
          "quote": params["quote"]
      }
      ai_quotes.append(quote)
      return quote, 201

ზემოთ მოცემულ კოდში, POST მეთოდმა მიიღო ციტატის ID. შემდეგ, reqparse-ის გამოყენებით, მან მოიძია ავტორი და ციტატა მოთხოვნიდან, ინახავდა მათ პარამების ლექსიკონში.

თუ ციტატა მითითებული ID-ით უკვე არსებობს, მაშინ მეთოდი აჩვენებს შესაბამის შეტყობინებას და კოდს 400.

თუ ციტატა მითითებული ID-ით ჯერ არ არის შექმნილი, მეთოდი ქმნის ახალ ჩანაწერს მითითებული ID-ით და ავტორით, ასევე სხვა პარამეტრებით. შემდეგ ის ამატებს ჩანაწერს ai_quotes სიაში და აბრუნებს ჩანაწერს ახალი ციტატით 201 კოდთან ერთად.

ახლა ჩვენ ვქმნით PUT მეთოდს საცავში არსებული ციტატის შესაცვლელად

def put(self, id):
      parser = reqparse.RequestParser()
      parser.add_argument("author")
      parser.add_argument("quote")
      params = parser.parse_args()
      for quote in ai_quotes:
          if(id == quote["id"]):
              quote["author"] = params["author"]
              quote["quote"] = params["quote"]
              return quote, 200
      
      quote = {
          "id": id,
          "author": params["author"],
          "quote": params["quote"]
      }
      
      ai_quotes.append(quote)
      return quote, 201

PUT მეთოდი, წინა მაგალითის მსგავსად, იღებს ID-ს და შეყვანას და აანალიზებს ციტატის პარამეტრებს reqparse-ის გამოყენებით.

თუ ციტატა მითითებული ID-ით არსებობს, მეთოდი განაახლებს მას ახალი პარამეტრებით და შემდეგ გამოაქვს განახლებული ციტატა 200 კოდით. ​​თუ ჯერ არ არის ციტატა მითითებული ID-ით, შეიქმნება ახალი ჩანაწერი 201 კოდით.

და ბოლოს, მოდით შევქმნათ DELETE მეთოდი ციტატის ამოსაღებად, რომელიც აღარ არის შთამაგონებელი.

def delete(self, id):
      global ai_quotes
      ai_quotes = [qoute for qoute in ai_quotes if qoute["id"] != id]
      return f"Quote with id {id} is deleted.", 200

ეს მეთოდი შესაყვანად იღებს ციტატის ID-ს და განაახლებს ai_quotes სიას გაზიარებული სიის გამოყენებით.

ახლა, როდესაც ჩვენ შევქმენით ყველა მეთოდი, ყველაფერი რაც უნდა გავაკეთოთ არის უბრალოდ დაამატოთ რესურსი API-ში, დავაყენოთ ბილიკი და გავუშვათ Flask.

api.add_resource(Quote, "/ai-quotes", "/ai-quotes/", "/ai-quotes/<int:id>")
if __name__ == '__main__':
    app.run(debug=True)

ჩვენი REST API სერვისი მზად არის!

შემდეგი, ჩვენ შეგვიძლია შევინახოთ კოდი app.py ფაილში მისი გაშვებით კონსოლში ბრძანებით:

python3 app.py

თუ ყველაფერი კარგადაა, მაშინ მივიღებთ მსგავს რამეს:

* გამართვის რეჟიმი: ჩართულია
* სირბილი 127.0.0.1:5000/ (დააჭირეთ CTRL+C გასასვლელად)
* გადატვირთვა stat-ით
* Debugger აქტიურია!
* გამართვის PIN: XXXXXXX

API-ს ტესტირება

API-ის შექმნის შემდეგ საჭიროა მისი ტესტირება.

ეს შეიძლება გაკეთდეს curl console უტილიტის ან Insomnia REST კლიენტის გამოყენებით, ან API-ის გამოქვეყნებით Rapid API-ზე.

ჩვენი API-ს გამოქვეყნება

RapidAPI არის ყველაზე დიდი ბაზარი მსოფლიოში 10-ზე მეტი API-ით (და დაახლოებით 000 მილიონი დეველოპერებით).

RapidAPI არა მხოლოდ უზრუნველყოფს ერთიან ინტერფეისს მესამე მხარის API-ებთან მუშაობისთვის, არამედ საშუალებას გაძლევთ სწრაფად და მარტივად გამოაქვეყნოთ თქვენი საკუთარი API.

დან გააკეთე, თქვენ ჯერ უნდა გამოაქვეყნოთ იგი ქსელის რომელიმე სერვერზე. ჩვენს შემთხვევაში, ჩვენ გამოვიყენებთ Heroku. მასთან მუშაობამ არ უნდა გამოიწვიოს რაიმე სირთულე, (შეგიძლიათ მეტი გაიგოთ ამის შესახებ აქ).

როგორ გამოაქვეყნოთ თქვენი API Heroku-ზე

1. დააინსტალირეთ Heroku.

პირველი ნაბიჯი არის Heroku Command Line Interface (CLI) რეგისტრაცია და ინსტალაცია. ეს მუშაობს Ubuntu 16+-ზე.

sudo snap install heroku --classic

შემდეგ ჩვენ შევდივართ:

ჰეროკუ შესვლა

2. დაამატეთ საჭირო ფაილები.

ახლა ჩვენ უნდა დავამატოთ ფაილები გამოსაქვეყნებლად ჩვენს აპლიკაციაში არსებულ საქაღალდეში:

• მოთხოვნები.txt პითონის საჭირო მოდულების სიით;
• პროფილი, რომელიც განსაზღვრავს რომელი ბრძანებები უნდა შესრულდეს აპლიკაციის გასაშვებად;
• .gitignore - ფაილების გამორიცხვა, რომლებიც არ არის საჭირო სერვერზე.

მოთხოვნები.txt ფაილი შეიცავს შემდეგ ხაზებს:

• flask
• კოლბა-დამსვენებელი
• გუნიკორნი

გთხოვთ, გაითვალისწინოთ, რომ ჩვენ დავამატეთ Gunicorn (Python WSGI HTTP სერვერი) სიაში, რადგან ჩვენი აპლიკაციის სერვერზე გაშვება გვჭირდება.

პროფილი შეიცავს:

ვებ: Gunicorn აპლიკაცია: აპლიკაცია

.gitignore-ის შინაარსი:

*.pyc
__pycache__/

ახლა, როდესაც ფაილები იქმნება, მოდით, ინიციალიზაცია გავუკეთოთ git repo-ს და შევასრულოთ:

git init
git add
git commit -m "First API commit"

3. შექმენით ახალი Heroku აპი.

heroku create

სამაგისტრო ფილიალის დისტანციურ Heroku რეპოში გადატანა:

git push heroku master

ახლა თქვენ შეგიძლიათ დაიწყოთ API სერვისის გახსნით ბრძანებებით:

heroku ps:scale web=1
heroku open
 

API ხელმისაწვდომი იქნება მისამართზე your-random-heroku-name.herokuapp.com/ai-quotes.

როგორ დავამატოთ თქვენი Python API RapidAPI ბაზარზე

მას შემდეგ, რაც API სერვისი გამოქვეყნდება Heroku-ზე, შეგიძლიათ დაამატოთ ის Rapid API-ში. Აქ დეტალური დოკუმენტაცია ამ თემაზე.

1. შექმენით RapidAPI ანგარიში.

ჩვენ ვრეგისტრირებთ უფასო ანგარიშს - ეს შეიძლება გაკეთდეს Facebook-ის, Google-ის, GitHub-ის გამოყენებით.

2. დაამატეთ API მართვის პანელში.

3. შემდეგ შეიყვანეთ ზოგადი ინფორმაცია თქვენი API-ის შესახებ.

4. “Add API”-ზე დაწკაპუნების შემდეგ ჩნდება ახალი გვერდი, სადაც შეგიძლიათ შეიყვანოთ ინფორმაცია ჩვენი API-ს შესახებ.

5. ახლა თქვენ შეგიძლიათ ხელით შეიყვანოთ API ბოლო წერტილები, ან ჩამოტვირთოთ swagger ფაილი OpenAPI-ის გამოყენებით.

ახლა თქვენ უნდა დააყენოთ ჩვენი API-ს ბოლო წერტილები ბოლო წერტილების გვერდზე. ჩვენს შემთხვევაში, ბოლო წერტილები შეესაბამება CRUD-ის კონცეფციას (მიიღე, განათავსე, დააყენე, წაშალე).

შემდეგი, თქვენ უნდა შექმნათ GET AI Quote საბოლოო წერტილი, რომელიც აჩვენებს შემთხვევით ციტატას (თუ ID არის ნაგულისხმევი) ან ციტატა მითითებული ID-სთვის.

საბოლოო წერტილის შესაქმნელად, თქვენ უნდა დააჭიროთ ღილაკს "შექმენით ბოლო წერტილი".

ჩვენ ვიმეორებთ ამ პროცესს ყველა სხვა API საბოლოო წერტილისთვის. Სულ ეს არის! გილოცავთ, თქვენ გამოაქვეყნეთ თქვენი API!

თუ ყველაფერი კარგად წავიდა, API გვერდი ასე გამოიყურება:

დასკვნა

ამ სტატიაში ჩვენ გავიარეთ Python-ში ჩვენი RESTful API სერვისის შექმნის პროცესი, ჰეროკუს ღრუბელში API-ს გამოქვეყნების და RapidAPI დირექტორიაში დამატების პროცესში.

მაგრამ სატესტო ვერსიაში ნაჩვენები იყო მხოლოდ API განვითარების ძირითადი პრინციპები - არ იყო გათვალისწინებული ისეთი ნიუანსი, როგორიცაა უსაფრთხოება, შეცდომების ტოლერანტობა და მასშტაბურობა.

რეალური API-ის შემუშავებისას ეს ყველაფერი უნდა იყოს გათვალისწინებული.

წყარო: www.habr.com