Python કોડની 4 મિલિયન લીટીઓ ટાઇપચેક કરવાનો માર્ગ. ભાગ 1

આજે અમે તમારા ધ્યાન પર સામગ્રીના અનુવાદનો પ્રથમ ભાગ લાવીએ છીએ કે કેવી રીતે ડ્રૉપબૉક્સ પાયથોન કોડના પ્રકાર નિયંત્રણ સાથે વ્યવહાર કરે છે.

ડ્રૉપબૉક્સ પાયથોનમાં ઘણું લખે છે. તે એક એવી ભાષા છે જેનો અમે બેક-એન્ડ સેવાઓ અને ડેસ્કટોપ ક્લાયંટ એપ્લિકેશન્સ બંને માટે ખૂબ જ વ્યાપકપણે ઉપયોગ કરીએ છીએ. અમે Go, TypeScript અને Rust નો પણ ઘણો ઉપયોગ કરીએ છીએ, પરંતુ Python અમારી મુખ્ય ભાષા છે. અમારા સ્કેલને ધ્યાનમાં લેતા, અને અમે પાયથોન કોડની લાખો લીટીઓ વિશે વાત કરી રહ્યા છીએ, તે બહાર આવ્યું છે કે આવા કોડની ગતિશીલ ટાઇપિંગ તેની સમજને બિનજરૂરી રીતે જટિલ બનાવે છે અને મજૂર ઉત્પાદકતાને ગંભીર અસર કરવાનું શરૂ કરે છે. આ સમસ્યાને હળવી કરવા માટે, અમે ધીમે ધીમે અમારા કોડને mypy નો ઉપયોગ કરીને સ્ટેટિક ટાઇપ ચેકિંગમાં સંક્રમણ કરવાનું શરૂ કર્યું છે. આ કદાચ પાયથોન માટે સૌથી વધુ લોકપ્રિય એકલ પ્રકારની ચકાસણી સિસ્ટમ છે. Mypy એક ઓપન સોર્સ પ્રોજેક્ટ છે, તેના મુખ્ય વિકાસકર્તાઓ ડ્રૉપબૉક્સમાં કામ કરે છે.

ડ્રૉપબૉક્સ આ સ્કેલ પર પાયથોન કોડમાં સ્ટેટિક ટાઇપ ચેકિંગનો અમલ કરનારી પ્રથમ કંપનીઓમાંની એક હતી. આ દિવસોમાં હજારો પ્રોજેક્ટ્સમાં Mypy નો ઉપયોગ થાય છે. આ સાધન અસંખ્ય વખત, જેમ તેઓ કહે છે, "યુદ્ધમાં પરીક્ષણ કર્યું." આપણે અત્યારે જ્યાં છીએ ત્યાં સુધી પહોંચવા માટે આપણે ઘણો લાંબો રસ્તો કાઢ્યો છે. રસ્તામાં, ઘણા અસફળ ઉપક્રમો અને નિષ્ફળ પ્રયોગો હતા. આ પોસ્ટ મારા સંશોધન પ્રોજેક્ટના ભાગ રૂપે તેની ખડકાળ શરૂઆતથી લઈને આજના દિવસ સુધી, પાયથોનમાં સ્ટેટિક ટાઈપ ચેકિંગના ઈતિહાસને આવરી લે છે, જ્યારે અગણિત વિકાસકર્તાઓ જેઓ પાયથોનમાં લખે છે તેમના માટે ટાઈપ ચેકિંગ અને ટાઈપ ઈંટીંગ સામાન્ય બની ગયા છે. આ મિકેનિઝમ્સ હવે IDEs અને કોડ વિશ્લેષકો જેવા ઘણા સાધનો દ્વારા સમર્થિત છે.

→ બીજો ભાગ વાંચો

ટાઇપ ચેકિંગ શા માટે જરૂરી છે?

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

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

• શું આ કાર્ય પરત કરી શકે છે None?
• આ દલીલ શું હોવી જોઈએ? items?
• લક્ષણ પ્રકાર શું છે id: int તે છે, str, અથવા કદાચ અમુક કસ્ટમ પ્રકાર?
• શું આ દલીલ સૂચિ હોવી જોઈએ? શું તેને ટપલ પસાર કરવું શક્ય છે?

જો તમે નીચેના ટાઇપ-એનોટેડ કોડ સ્નિપેટ જુઓ અને સમાન પ્રશ્નોના જવાબ આપવાનો પ્રયાસ કરો, તો તે તારણ આપે છે કે આ સૌથી સરળ કાર્ય છે:

class Resource:
    id: bytes
    ...
    def read_metadata(self, 
                      items: Sequence[str]) -> Dict[str, MetadataItem]:
        ...

• read_metadata પરત કરતું નથી None, કારણ કે વળતર પ્રકાર નથી Optional[…].
• દલીલ items રેખાઓનો ક્રમ છે. તે રેન્ડમલી પુનરાવર્તિત કરી શકાતું નથી.
• વિશેષતા id બાઇટ્સની સ્ટ્રીંગ છે.

આદર્શ વિશ્વમાં, કોઈ એવી અપેક્ષા રાખે છે કે બિલ્ટ-ઇન દસ્તાવેજીકરણ (ડોકસ્ટ્રિંગ) માં આવી બધી સૂક્ષ્મતાનું વર્ણન કરવામાં આવશે. પરંતુ અનુભવ એ હકીકતના ઘણા ઉદાહરણો આપે છે કે તમારે જે કોડ સાથે કામ કરવું છે તેમાં આવા દસ્તાવેજો ઘણીવાર જોવા મળતા નથી. જો આવા દસ્તાવેજો કોડમાં હાજર હોય, તો પણ તેની સંપૂર્ણ શુદ્ધતા પર ગણતરી કરી શકાતી નથી. આ દસ્તાવેજો અસ્પષ્ટ, અચોક્કસ અને ગેરસમજ માટે ખુલ્લા હોઈ શકે છે. મોટી ટીમો અથવા મોટા પ્રોજેક્ટ્સમાં, આ સમસ્યા અત્યંત તીવ્ર બની શકે છે.

જ્યારે પાયથોન પ્રોજેક્ટ્સના પ્રારંભિક અથવા મધ્યવર્તી તબક્કામાં ઉત્કૃષ્ટ છે, ત્યારે અમુક સમયે સફળ પ્રોજેક્ટ્સ અને પાયથોનનો ઉપયોગ કરતી કંપનીઓને મહત્વપૂર્ણ પ્રશ્નનો સામનો કરવો પડી શકે છે: "શું આપણે બધું સ્થિર રીતે ટાઈપ કરેલી ભાષામાં ફરીથી લખવું જોઈએ?".

mypy જેવી ટાઈપ ચેકિંગ સિસ્ટમ્સ ડેવલપરને પ્રકારોનું વર્ણન કરવા માટે ઔપચારિક ભાષા પ્રદાન કરીને અને પ્રકાર ઘોષણાઓ પ્રોગ્રામ અમલીકરણ સાથે મેળ ખાતી હોય તે ચકાસીને (અને વૈકલ્પિક રીતે, તેમના અસ્તિત્વની તપાસ કરીને) ઉપરોક્ત સમસ્યાનું નિરાકરણ લાવે છે. સામાન્ય રીતે, અમે કહી શકીએ છીએ કે આ સિસ્ટમો અમારા નિકાલ પર ધ્યાનપૂર્વક તપાસેલા દસ્તાવેજો જેવું કંઈક મૂકે છે.

આવી સિસ્ટમોના ઉપયોગના અન્ય ફાયદા છે, અને તે પહેલેથી જ સંપૂર્ણપણે બિન-તુચ્છ છે:

• ટાઇપ ચેકિંગ સિસ્ટમ કેટલીક નાની (અને એટલી નાની નહીં) ભૂલો શોધી શકે છે. એક લાક્ષણિક ઉદાહરણ એ છે કે જ્યારે તેઓ મૂલ્યની પ્રક્રિયા કરવાનું ભૂલી જાય છે None અથવા કોઈ અન્ય વિશેષ સ્થિતિ.
• કોડ રિફેક્ટરિંગ ખૂબ જ સરળ છે કારણ કે ટાઇપ ચેકિંગ સિસ્ટમ કયા કોડને બદલવાની જરૂર છે તે વિશે ઘણી વખત ખૂબ જ સચોટ હોય છે. તે જ સમયે, અમને પરીક્ષણો સાથે 100% કોડ કવરેજની આશા રાખવાની જરૂર નથી, જે કોઈ પણ સંજોગોમાં, સામાન્ય રીતે શક્ય નથી. સમસ્યાનું કારણ શોધવા માટે અમારે સ્ટેક ટ્રેસની ઊંડાઈમાં તપાસ કરવાની જરૂર નથી.
• મોટા પ્રોજેક્ટ્સ પર પણ, mypy ઘણીવાર સેકન્ડના અપૂર્ણાંકમાં સંપૂર્ણ પ્રકારનું ચેકિંગ કરી શકે છે. અને પરીક્ષણોનો અમલ સામાન્ય રીતે દસ સેકંડ અથવા તો મિનિટ લે છે. ટાઇપ ચેકિંગ સિસ્ટમ પ્રોગ્રામરને ત્વરિત પ્રતિસાદ આપે છે અને તેને તેનું કામ ઝડપથી કરવા દે છે. તેણે હવે એકમ પરીક્ષણો જાળવવા માટે નાજુક અને સખત લખવાની જરૂર નથી કે જે વાસ્તવિક એન્ટિટીને મોક્સ અને પેચથી બદલે છે, ફક્ત કોડ પરીક્ષણ પરિણામો ઝડપથી મેળવવા માટે.

IDEs અને સંપાદકો જેમ કે PyCharm અથવા વિઝ્યુઅલ સ્ટુડિયો કોડ વિકાસકર્તાઓને કોડ પૂર્ણતા, એરર હાઇલાઇટિંગ અને સામાન્ય રીતે ઉપયોગમાં લેવાતી ભાષા રચનાઓ માટે સમર્થન આપવા માટે ટાઇપ એનોટેશનની શક્તિનો ઉપયોગ કરે છે. અને આ ફક્ત ટાઈપ કરવાના કેટલાક ફાયદા છે. કેટલાક પ્રોગ્રામરો માટે, આ બધું ટાઇપ કરવાની તરફેણમાં મુખ્ય દલીલ છે. આ એવી વસ્તુ છે જે અમલીકરણ પછી તરત જ ફાયદો થાય છે. પ્રકારો માટેના આ ઉપયોગ કેસમાં mypy જેવી અલગ પ્રકારની ચકાસણી સિસ્ટમની જરૂર નથી, જો કે તે નોંધવું જોઈએ કે mypy કોડ સાથે સુસંગત ટાઇપ એનોટેશન રાખવામાં મદદ કરે છે.

mypy ની પૃષ્ઠભૂમિ

માયપીનો ઇતિહાસ યુકેમાં, કેમ્બ્રિજમાં, હું ડ્રૉપબૉક્સમાં જોડાયો તેના થોડા વર્ષો પહેલા શરૂ થયો હતો. હું મારા ડોક્ટરલ સંશોધનના ભાગ રૂપે, સ્ટેટિકલી ટાઇપ કરેલી અને ગતિશીલ ભાષાઓના એકીકરણમાં સામેલ થયો છું. હું જેરેમી સીક અને વાલિદ તાહા દ્વારા અને ટાઈપ્ડ રેકેટ પ્રોજેક્ટ દ્વારા ઇન્ક્રીમેન્ટલ ટાઇપિંગ પરના લેખથી પ્રેરિત થયો હતો. મેં વિવિધ પ્રોજેક્ટ્સ માટે સમાન પ્રોગ્રામિંગ લેંગ્વેજનો ઉપયોગ કરવાની રીતો શોધવાનો પ્રયાસ કર્યો - નાની સ્ક્રિપ્ટોથી લઈને કોડ બેઝ સુધી જેમાં લાખો લીટીઓનો સમાવેશ થાય છે. તે જ સમયે, હું એ સુનિશ્ચિત કરવા માંગતો હતો કે કોઈપણ સ્કેલના પ્રોજેક્ટમાં, વ્યક્તિએ ખૂબ મોટી સમજૂતી કરવી ન પડે. આ બધાનો એક મહત્વનો ભાગ એ હતો કે ટાઇપ ન કરેલા પ્રોટોટાઇપ પ્રોજેક્ટમાંથી ક્રમશઃ વ્યાપક રીતે પરીક્ષણ કરાયેલ સ્ટેટિકલી ટાઇપ કરેલા ફિનિશ્ડ પ્રોડક્ટ તરફ આગળ વધવાનો વિચાર હતો. આ દિવસોમાં, આ વિચારોને મોટાભાગે મંજૂર કરવામાં આવે છે, પરંતુ 2010 માં તે એક સમસ્યા હતી જે હજી પણ સક્રિયપણે શોધાઈ રહી હતી.

પ્રકાર તપાસમાં મારું મૂળ કાર્ય પાયથોનને લક્ષ્યમાં રાખતું ન હતું. તેના બદલે, મેં નાની "હોમમેઇડ" ભાષાનો ઉપયોગ કર્યો અલોરે. અહીં એક ઉદાહરણ છે જે તમને સમજવા દેશે કે અમે શેના વિશે વાત કરી રહ્યા છીએ (ટાઈપ એનોટેશન અહીં વૈકલ્પિક છે):

def Fib(n as Int) as Int
  if n <= 1
    return n
  else
    return Fib(n - 1) + Fib(n - 2)
  end
end

એક સરળ મૂળ ભાષાનો ઉપયોગ એ વૈજ્ઞાનિક સંશોધનમાં ઉપયોગમાં લેવાતો સામાન્ય અભિગમ છે. આ એટલા માટે છે, ઓછામાં ઓછું એટલા માટે નહીં કે તે તમને ઝડપથી પ્રયોગો કરવા દે છે, અને એ પણ હકીકતને કારણે કે જેને અભ્યાસ સાથે કોઈ લેવાદેવા નથી તેને સરળતાથી અવગણી શકાય છે. વાસ્તવિક-વિશ્વ પ્રોગ્રામિંગ ભાષાઓ જટિલ અમલીકરણો સાથે મોટા પાયે અસાધારણ ઘટના હોય છે, અને આ પ્રયોગને ધીમું કરે છે. જો કે, સરળ ભાષા પર આધારિત કોઈપણ પરિણામો થોડા શંકાસ્પદ લાગે છે, કારણ કે આ પરિણામો મેળવવામાં સંશોધકે ભાષાઓના વ્યવહારિક ઉપયોગ માટે મહત્વપૂર્ણ વિચારણાઓનું બલિદાન આપ્યું હશે.

અલોર માટેનું મારું ટાઇપ ચેકર ખૂબ જ આશાસ્પદ લાગતું હતું, પરંતુ હું વાસ્તવિક કોડ સાથે પ્રયોગ કરીને તેને ચકાસવા માંગતો હતો, જે તમે કહી શકો છો, અલોરમાં લખાયેલું ન હતું. સદભાગ્યે મારા માટે, અલોર ભાષા મોટે ભાગે પાયથોન જેવા જ વિચારો પર આધારિત હતી. ટાઇપચેકરને રીમેક કરવા માટે તે પૂરતું સરળ હતું જેથી તે પાયથોનના સિન્ટેક્સ અને સિમેન્ટિક્સ સાથે કામ કરી શકે. આનાથી અમને ઓપન સોર્સ પાયથોન કોડમાં ટાઇપ ચેક કરવાનો પ્રયાસ કરવાની મંજૂરી મળી. આ ઉપરાંત, મેં અલોરમાં લખેલા કોડને પાયથોન કોડમાં કન્વર્ટ કરવા માટે એક ટ્રાન્સપિલર લખ્યું અને તેનો ઉપયોગ મારા ટાઇપચેકર કોડને અનુવાદિત કરવા માટે કર્યો. હવે મારી પાસે પાયથોનમાં લખેલી એક ટાઇપ ચેકિંગ સિસ્ટમ હતી જે પાયથોનના સબસેટને ટેકો આપે છે, તે અમુક પ્રકારની ભાષા! (કેટલાક આર્કિટેક્ચરલ નિર્ણયો જે અલોર માટે અર્થપૂર્ણ હતા તે પાયથોન માટે ખરાબ રીતે અનુકૂળ હતા, અને આ હજુ પણ mypy કોડબેઝના ભાગોમાં નોંધનીય છે.)

વાસ્તવમાં, મારી ટાઇપ સિસ્ટમ દ્વારા સપોર્ટેડ ભાષાને આ સમયે પાયથોન કહી શકાય નહીં: તે પાયથોન 3 ટાઇપ એનોટેશન સિન્ટેક્સની કેટલીક મર્યાદાઓને કારણે પાયથોનનો એક પ્રકાર હતો.

તે જાવા અને પાયથોનના મિશ્રણ જેવું લાગતું હતું:

int fib(int n):
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

તે સમયે મારા વિચારોમાંથી એક આ પ્રકારના પાયથોનને C, અથવા કદાચ JVM બાઇટકોડને કમ્પાઇલ કરીને પ્રદર્શનને સુધારવા માટે ટાઇપ એનોટેશનનો ઉપયોગ કરવાનો હતો. હું કમ્પાઇલર પ્રોટોટાઇપ લખવાના તબક્કે પહોંચ્યો, પરંતુ મેં આ વિચાર છોડી દીધો, કારણ કે ટાઇપ ચેકિંગ પોતે જ ખૂબ ઉપયોગી લાગતું હતું.

મેં સાન્ટા ક્લેરામાં PyCon 2013માં મારો પ્રોજેક્ટ રજૂ કર્યો. મેં આ વિશે જીવન માટે પરોપકારી પાયથોન સરમુખત્યાર ગિડો વાન રોસમ સાથે પણ વાત કરી. તેણે મને મારો પોતાનો વાક્યરચના છોડવા અને પ્રમાણભૂત પાયથોન 3 વાક્યરચના સાથે વળગી રહેવા માટે ખાતરી આપી. પાયથોન 3 ફંક્શન એનોટેશનને સપોર્ટ કરે છે, તેથી મારું ઉદાહરણ નીચે બતાવ્યા પ્રમાણે ફરીથી લખી શકાય છે, પરિણામે સામાન્ય પાયથોન પ્રોગ્રામ થાય છે:

def fib(n: int) -> int:
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

મારે કેટલાક સમાધાન કરવા પડ્યા હતા (સૌ પ્રથમ, હું એ નોંધવા માંગુ છું કે મેં આ જ કારણસર મારી પોતાની વાક્યરચના શોધ કરી છે). ખાસ કરીને, પાયથોન 3.3, તે સમયે ભાષાનું સૌથી તાજેતરનું સંસ્કરણ, ચલ એનોટેશનને સમર્થન આપતું નથી. મેં આવા ટીકાઓની સિન્ટેક્ટિક ડિઝાઇન માટેની વિવિધ શક્યતાઓ વિશે ઈ-મેલ દ્વારા ગાઈડો સાથે ચર્ચા કરી. અમે ચલ માટે ટાઈપ કોમેન્ટ્સનો ઉપયોગ કરવાનું નક્કી કર્યું. આનાથી ઇચ્છિત હેતુ પૂરો થયો, પરંતુ તે કંઈક અંશે બોજારૂપ હતું (પાયથોન 3.6 એ અમને એક સરસ સિન્ટેક્સ આપ્યો):

products = []  # type: List[str]  # Eww

Python 2 ને સપોર્ટ કરવા માટે ટાઈપ કોમેન્ટ્સ પણ કામમાં આવી, જેમાં ટાઈપ એનોટેશન માટે બિલ્ટ-ઈન સપોર્ટ નથી:

f fib(n):
    # type: (int) -> int
    if n <= 1:
        return n
    else:
        return fib(n - 1) + fib(n - 2)

તે બહાર આવ્યું છે કે આ (અને અન્ય) ટ્રેડ-ઓફ્સથી ખરેખર કોઈ ફરક પડતો નથી - સ્થિર ટાઈપિંગના ફાયદાઓનો અર્થ એ થયો કે વપરાશકર્તાઓ ટૂંક સમયમાં આદર્શ કરતાં ઓછા વાક્યરચના વિશે ભૂલી ગયા. ટાઇપ-ચેક કરેલા પાયથોન કોડમાં કોઈ ખાસ સિન્ટેક્ટિક કન્સ્ટ્રક્ટનો ઉપયોગ કરવામાં આવ્યો ન હોવાથી, હાલના પાયથોન ટૂલ્સ અને કોડ પ્રોસેસિંગ પ્રક્રિયાઓ સામાન્ય રીતે કામ કરવાનું ચાલુ રાખ્યું છે, જે વિકાસકર્તાઓ માટે નવું ટૂલ શીખવાનું વધુ સરળ બનાવે છે.

મેં મારી ગ્રેજ્યુએટ થીસીસ પૂર્ણ કરી લીધા પછી ગાઈડોએ મને ડ્રૉપબૉક્સમાં જોડાવા માટે પણ સમજાવ્યું. માયપી વાર્તાનો સૌથી રસપ્રદ ભાગ અહીંથી શરૂ થાય છે.

ચાલુ રહી શકાય…

પ્રિય વાચકો! જો તમે Python નો ઉપયોગ કરો છો, તો કૃપા કરીને અમને આ ભાષામાં તમે વિકસાવેલા પ્રોજેક્ટના સ્કેલ વિશે જણાવો.

સોર્સ: www.habr.com