પાયથોનમાં API લખવું (ફ્લાસ્ક અને RapidAPI સાથે)

જો તમે આ લેખ વાંચી રહ્યા છો, તો તમે કદાચ પહેલાથી જ એવી શક્યતાઓથી પરિચિત છો જે API (એપ્લિકેશન પ્રોગ્રામિંગ ઈન્ટરફેસ) નો ઉપયોગ કરતી વખતે ખુલે છે.

તમારી એપ્લિકેશનમાં ઘણા બધા સાર્વજનિક APIમાંથી એક ઉમેરીને, તમે આ એપ્લિકેશનની કાર્યક્ષમતાને વિસ્તૃત કરી શકો છો અથવા તેને જરૂરી ડેટા સાથે પૂરક બનાવી શકો છો. પરંતુ જો તમે એક વિશિષ્ટ સુવિધા વિકસાવી હોય જે તમે સમુદાય સાથે શેર કરવા માંગો છો તો શું?

જવાબ સરળ છે: તમારે જરૂર છે તમારું પોતાનું API બનાવો.

જ્યારે આ શરૂઆતમાં મુશ્કેલ કાર્ય જેવું લાગે છે, તે વાસ્તવમાં એકદમ સરળ છે. અમે તમને બતાવીશું કે પાયથોન સાથે આ કેવી રીતે કરવું.

તમારે પ્રારંભ કરવા માટે શું કરવાની જરૂર છે

API વિકાસ માટે જરૂરી છે:

• પાયથોન 3;
• બાટલી — વેબ એપ્લિકેશન બનાવવા માટે સરળ અને ઉપયોગમાં સરળ માળખું;
• ફ્લાસ્ક-રેસ્ટફુલ ફ્લાસ્ક માટે એક એક્સ્ટેંશન છે જે તમને ઝડપથી અને ન્યૂનતમ રૂપરેખાંકન સાથે REST API વિકસાવવા માટે પરવાનગી આપે છે.

ઇન્સ્ટોલેશન આદેશ દ્વારા કરવામાં આવે છે:

pip install flask-restful

અમે નવા નિશાળીયા માટે મફત સઘન પ્રોગ્રામિંગની ભલામણ કરીએ છીએ:
C# માં ટેલિગ્રામ બોટ વિકાસ - ઓગસ્ટ 26-28. એક મફત સઘન જે તમને સહાયક બૉટ્સ કેવી રીતે કાર્ય કરે છે તે સમજવાની મંજૂરી આપે છે, ટેલિગ્રામ API સાથે કામ કરવાની સુવિધાઓ અને અન્ય ઘોંઘાટ. ટોચના ત્રણ સહભાગીઓને સ્કિલબોક્સ તરફથી 30 રુબેલ્સ પ્રાપ્ત થશે.

તમે શરૂ કરો તે પહેલાં

અમે મૂળભૂત સાથે RESTful API વિકસાવવા જઈ રહ્યા છીએ CRUID કાર્યક્ષમતા.

કાર્યને સંપૂર્ણ રીતે સમજવા માટે, ચાલો ઉપર જણાવેલ બે શબ્દોને સમજીએ.

REST શું છે?

REST API (રિપ્રેઝેન્ટેશનલ સ્ટેટ ટ્રાન્સફર) એ એક API છે જે ડેટાની આપલે કરવા માટે HTTP વિનંતીઓનો ઉપયોગ કરે છે.

REST API એ ચોક્કસ માપદંડોને પૂર્ણ કરવા આવશ્યક છે:

• ક્લાયંટ-સર્વર આર્કિટેક્ચર: ક્લાયંટ વપરાશકર્તા ઇન્ટરફેસ સાથે ક્રિયાપ્રતિક્રિયા કરે છે, અને સર્વર બેકએન્ડ અને ડેટા સ્ટોર સાથે ક્રિયાપ્રતિક્રિયા કરે છે. ક્લાયંટ અને સર્વર સ્વતંત્ર છે, તેમાંના કોઈપણને બીજાથી અલગથી બદલી શકાય છે.
• સ્ટેટલેસ - સર્વર પર કોઈ ક્લાયન્ટ ડેટા સંગ્રહિત નથી. સત્ર સ્થિતિ ક્લાયંટ બાજુ પર સંગ્રહિત છે.
• કેશેબિલિટી - ક્લાઈન્ટ એકંદર પ્રદર્શનને સુધારવા માટે સર્વર પ્રતિસાદોને કેશ કરી શકે છે.

CRUD શું છે?

સીઆરયુડી એક પ્રોગ્રામિંગ ખ્યાલ છે જે ચાર મૂળભૂત ક્રિયાઓનું વર્ણન કરે છે (બનાવો, વાંચો, અપડેટ કરો અને કાઢી નાખો).

REST API માં, વિનંતીના પ્રકારો અને વિનંતી પદ્ધતિઓ પોસ્ટ, ગેટ, પુટ, ડિલીટ જેવી ક્રિયાઓ માટે જવાબદાર છે.

હવે અમે મૂળભૂત શરતો સાથે વ્યવહાર કર્યો છે, અમે API બનાવવાનું શરૂ કરી શકીએ છીએ.

વિકાસ

ચાલો આર્ટિફિશિયલ ઇન્ટેલિજન્સ વિશેના અવતરણોનો ભંડાર બનાવીએ. AI એ આજે ​​સૌથી ઝડપથી વિકસતી તકનીકોમાંની એક છે, અને Python એ AI સાથે કામ કરવા માટેનું એક લોકપ્રિય સાધન છે.

આ API સાથે, પાયથોન ડેવલપર ઝડપથી AI વિશે જાણી શકે છે અને નવી સિદ્ધિઓથી પ્રેરિત થઈ શકે છે. જો વિકાસકર્તા પાસે આ વિષય પર મૂલ્યવાન વિચારો હોય, તો તે તેમને રીપોઝીટરીમાં ઉમેરી શકશે.

ચાલો જરૂરી મોડ્યુલો આયાત કરીને અને ફ્લાસ્ક સેટ કરીને શરૂઆત કરીએ:

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

આ સ્નિપેટમાં, ફ્લાસ્ક, એપીઆઈ અને રિસોર્સ એ આપણને જોઈતા વર્ગો છે.

Reqparse એ ફ્લાસ્ક-રેસ્ટફુલ રિક્વેસ્ટ પાર્સિંગ ઇન્ટરફેસ છે... રેન્ડમ ક્વોટ પ્રદર્શિત કરવા માટે તમારે રેન્ડમ મોડ્યુલની પણ જરૂર પડશે.

હવે આપણે AI વિશે અવતરણોનો ભંડાર બનાવીશું.

દરેક રેપો એન્ટ્રીમાં શામેલ હશે:

• ડિજિટલ 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."
    }
]

હવે આપણે ક્વોટ રિસોર્સ ક્લાસ બનાવવાની જરૂર છે જે અમારા 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

જો IDમાં ડિફોલ્ટ મૂલ્ય હોય તો GET પદ્ધતિ રેન્ડમ ક્વોટ આપે છે, એટલે કે. પદ્ધતિને કૉલ કરતી વખતે ID સેટ કરવામાં આવી ન હતી.

જો તે સેટ કરેલ હોય, તો પદ્ધતિ અવતરણો વચ્ચે શોધે છે અને આપેલ ID સમાવે છે તે શોધે છે. જો કંઈ ન મળે, તો સંદેશ "ક્વોટ મળ્યો નથી, 404" પ્રદર્શિત થાય છે.

યાદ રાખો, જો વિનંતિ સફળ થઈ હોય તો પદ્ધતિ 200 ની HTTP સ્થિતિ આપે છે અને જો એન્ટ્રી ન મળી હોય તો 404.

હવે રીપોઝીટરીમાં નવો ક્વોટ ઉમેરવા માટે POST પદ્ધતિ બનાવીએ

તમે જેમ ટાઈપ કરશો તેમ તેને દરેક નવા ક્વોટનું આઈડી મળશે. વધુમાં, 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 નો ઉપયોગ કરીને, તેણે વિનંતીમાંથી લેખક અને અવતરણ મેળવ્યા, તેમને params શબ્દકોશમાં સંગ્રહિત કર્યા.

જો ઉલ્લેખિત 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.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 દબાવો)
* સ્ટેટ સાથે પુનઃપ્રારંભ
* ડીબગર સક્રિય છે!
* ડીબગર પિન: XXXXXXX

API નું પરીક્ષણ કરી રહ્યું છે

API બનાવ્યા પછી, તેનું પરીક્ષણ કરવાની જરૂર છે.

આ curl કન્સોલ ઉપયોગિતા અથવા અનિદ્રા REST ક્લાયંટનો ઉપયોગ કરીને અથવા Rapid API પર API પ્રકાશિત કરીને કરી શકાય છે.

અમારા API પ્રકાશિત કરી રહ્યા છીએ

RapidAPI એ 10 થી વધુ API (અને લગભગ 000 મિલિયન વિકાસકર્તાઓ) સાથે વિશ્વનું સૌથી મોટું માર્કેટપ્લેસ છે.

RapidAPI તૃતીય-પક્ષ API સાથે કામ કરવા માટે માત્ર એક જ ઈન્ટરફેસ પ્રદાન કરતું નથી, પણ તમને તમારા પોતાના APIને ઝડપથી અને સરળતાથી પ્રકાશિત કરવાની પણ મંજૂરી આપે છે.

માટે આ કરવા માટે, તમારે પહેલા તેને નેટવર્ક પરના કેટલાક સર્વર પર પ્રકાશિત કરવાની જરૂર છે. અમારા કિસ્સામાં, અમે ઉપયોગ કરીશું હેરોકુ. તેની સાથે કામ કરવાથી કોઈ મુશ્કેલી ન થવી જોઈએ, (તમે અહીં તેના વિશે વધુ જાણી શકો છો).

Heroku પર તમારું API કેવી રીતે પ્રકાશિત કરવું

1. Heroku ઇન્સ્ટોલ કરો.

પ્રથમ પગલું Heroku કમાન્ડ લાઇન ઇન્ટરફેસ (CLI) ની નોંધણી અને ઇન્સ્ટોલ કરવાનું છે. આ Ubuntu 16+ પર કામ કરે છે.

sudo snap install heroku --classic

પછી અમે લૉગ ઇન કરીએ છીએ:

heroku લૉગિન

2. જરૂરી ફાઇલો ઉમેરો.

હવે અમારે અમારી એપ્લિકેશનમાં ફોલ્ડરમાં પ્રકાશિત કરવા માટે ફાઇલો ઉમેરવાની જરૂર છે:

• જરૂરી પાયથોન મોડ્યુલોની યાદી સાથે requirements.txt;
• Procfile, જે સ્પષ્ટ કરે છે કે એપ્લીકેશન ચલાવવા માટે કયા આદેશો અમલમાં મૂકવા જોઈએ;
• .gitignore - સર્વર પર જરૂરી ન હોય તેવી ફાઇલોને બાકાત રાખવા માટે.

requirements.txt ફાઇલમાં નીચેની લીટીઓ હશે:

• ફ્લાસ્ક
• ફ્લાસ્ક-આરામદાયક
• ગનકોર્ન

મહેરબાની કરીને નોંધ કરો કે અમે સૂચિમાં gunicorn (Python WSGI HTTP સર્વર) ઉમેર્યું છે કારણ કે અમારે સર્વર પર અમારી એપ્લિકેશન ચલાવવાની જરૂર છે.

પ્રોફાઇલમાં શામેલ હશે:

web: gunicorn app:app

.gitignore ની સામગ્રી:

*.pyc
__pycache__/

હવે જ્યારે ફાઇલો બનાવવામાં આવી છે, ચાલો ગિટ રેપોને પ્રારંભ કરીએ અને કમિટ કરીએ:

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

3. નવી Heroku એપ્લિકેશન બનાવો.

heroku create

માસ્ટર બ્રાન્ચને રિમોટ હેરોકુ રેપો પર ધકેલવું:

git push heroku master

હવે તમે આદેશો સાથે API સેવા ખોલીને પ્રારંભ કરી શકો છો:

heroku ps:scale web=1
heroku open
 

API પર ઉપલબ્ધ થશે your-random-heroku-name.herokuapp.com/ai-quotes.

તમારા પાયથોન API ને RapidAPI માર્કેટપ્લેસમાં કેવી રીતે ઉમેરવું

એકવાર API સેવા Heroku પર પ્રકાશિત થઈ જાય, પછી તમે તેને Rapid API માં ઉમેરી શકો છો. અહીં વિગતવાર દસ્તાવેજીકરણ આ વિષય પર.

1. RapidAPI એકાઉન્ટ બનાવો.

અમે એક મફત એકાઉન્ટ રજીસ્ટર કરીએ છીએ - આ ફેસબુક, ગૂગલ, ગિટહબનો ઉપયોગ કરીને કરી શકાય છે.

2. કંટ્રોલ પેનલમાં API ઉમેરો.

3. આગળ, તમારા API વિશે સામાન્ય માહિતી દાખલ કરો.

4. "Add API" પર ક્લિક કર્યા પછી એક નવું પૃષ્ઠ દેખાય છે જ્યાં તમે અમારા API વિશે માહિતી દાખલ કરી શકો છો.

5. હવે તમે મેન્યુઅલી API એન્ડપોઇન્ટ દાખલ કરી શકો છો અથવા ડાઉનલોડ કરી શકો છો સ્વેગર ફાઇલ OpenAPI નો ઉપયોગ કરીને.

સારું, હવે તમારે એન્ડપોઇન્ટ્સ પૃષ્ઠ પર અમારા API ના અંતિમ બિંદુઓ સેટ કરવાની જરૂર છે. અમારા કિસ્સામાં, અંતિમ બિંદુઓ CRUD (મેળવો, પોસ્ટ કરો, મૂકો, કાઢી નાખો) ના ખ્યાલને અનુરૂપ છે.

આગળ, તમારે એક GET AI ક્વોટ એન્ડપોઇન્ટ બનાવવાની જરૂર છે જે રેન્ડમ ક્વોટ (જો ID ડિફોલ્ટ હોય તો) અથવા ઉલ્લેખિત ID માટે ક્વોટ દર્શાવે છે.

એન્ડપોઇન્ટ બનાવવા માટે, તમારે "એન્ડપોઇન્ટ બનાવો" બટનને ક્લિક કરવાની જરૂર છે.

અમે આ પ્રક્રિયાને અન્ય તમામ API એન્ડપોઇન્ટ માટે પુનરાવર્તિત કરીએ છીએ. બસ એટલું જ! અભિનંદન, તમે તમારું API પ્રકાશિત કર્યું છે!

જો બધું બરાબર ચાલે છે, તો API પૃષ્ઠ કંઈક આના જેવું દેખાશે:

નિષ્કર્ષ

આ લેખમાં, અમે પાયથોનમાં અમારી પોતાની RESTful API સેવા બનાવવાની પ્રક્રિયા સાથે, Heroku ક્લાઉડ પર API પ્રકાશિત કરવાની અને તેને RapidAPI ડિરેક્ટરીમાં ઉમેરવાની પ્રક્રિયામાંથી પસાર થયા.

પરંતુ પરીક્ષણ સંસ્કરણમાં, API વિકાસના ફક્ત મૂળભૂત સિદ્ધાંતો દર્શાવવામાં આવ્યા હતા - સુરક્ષા, ખામી સહિષ્ણુતા અને માપનીયતા જેવી ઘોંઘાટ ધ્યાનમાં લેવામાં આવી ન હતી.

વાસ્તવિક API વિકસાવતી વખતે, આ બધું ધ્યાનમાં લેવું આવશ્યક છે.

સોર્સ: www.habr.com