mypy में issubclass() और Any: टाइप नैरोइंग क्यों विफल होती और इससे कैसे निपटें

mypy में Any के साथ issubclass() टाइप नैरोइंग क्यों विफल होती, इसके खतरे क्या हैं, और सुरक्षित तरीका—isinstance(x, type) गार्ड या स्पष्ट type एनोटेशन—कैसे अपनाएँ.

mypy में साधारण issubclass() जाँच कई बार प्रकारों को संकुचित करने में चुपचाप विफल क्यों होती है, और इससे कैसे निपटें

समस्या का अवलोकन

mypy के साथ टाइप नैरोइंग तब तक सहज लगती है जब तक Any तस्वीर में नहीं आता। एक आम गलती यह मान लेना है कि issubclass() Any प्रकार के मान को अधिक सटीक प्रकार में संकुचित कर देगा। व्यवहार में ऐसा नहीं होता, और जिस शाखा में सीधे issubclass() की जाँच होती है, वहां कोई उपयोगी संकुचन नहीं मिलता।

न्यूनतम उदाहरण

नीचे दिया गया स्निपेट अपेक्षा और वास्तविक व्यवहार के बीच अंतर दिखाता है। पहली शाखा isinstance(x, type) को issubclass() के साथ मिलाती है, और mypy सही संकुचन पहचान लेता है। दूसरी शाखा केवल issubclass() का इस्तेमाल करती है और Any पर ही बनी रहती है।

from typing import Any
class BaseUnit:
    pass
def probe(x: Any) -> None:
    if isinstance(x, type) and issubclass(x, BaseUnit):
        reveal_type(x)  # प्रकट किया गया प्रकार "Type[BaseUnit]" है
    if issubclass(x, BaseUnit):
        reveal_type(x)  # प्रकट किया गया प्रकार "Any" है

क्या हो रहा है

mypy में एक जाना-पहचाना मुद्दा है: यदि जाँचा जा रहा मान Any प्रकार का है, तो issubclass() टाइप नैरोइंग नहीं करता। भले ही जाँच अर्थ के स्तर पर पास हो जाए, चेकर के नज़रिए से प्रकार Any ही रहता है, इसलिए उदाहरण की दूसरी शाखा में प्रकार संकुचित नहीं होता।

दूसरी शर्त का एक अलग जोखिम भी है: issubclass() अपने पहले आर्गुमेंट के रूप में एक प्रकार की अपेक्षा करता है। अगर वह प्रकार नहीं है, तो कॉल रनटाइम पर अपवाद उठा सकती है। दूसरे शब्दों में, issubclass(x, BaseUnit) को कॉल करना अप्रत्यक्ष तौर पर यह मान लेना है कि x एक प्रकार है, जो अवांछित साइड इफेक्ट हो सकता है। यदि ऐसा आसर्शन उद्देश्यपूर्ण है, तो इसे वेरिएबल के प्रकार में ही दिखाना अधिक स्पष्ट और सुरक्षित है—उदाहरण के लिए x: type का उपयोग करके।

निहितार्थ, सैद्धांतिक रूप में

नीचे दिए गए उदाहरण में इस आसर्शन-समान साइड इफेक्ट को टाइप सिस्टम के दृष्टिकोण से दिखाया गया है। यह एक सैद्धांतिक चित्रण है; कोई बड़ा टाइप चेकर आज ठीक ऐसे काम नहीं करता, लेकिन विचार यही है कि कॉल पहले आर्गुमेंट के प्रकार होने की निहित धारणा लेकर आती है।

# सैद्धांतिक आउटपुट। वर्तमान में कोई बड़ा टाइप चेकर इस तरह काम नहीं करता।
def inspect(y: Any):
    if issubclass(y, int):
        reveal_type(y)  # टाइप[int]
    reveal_type(y)      # टाइप       (!?)

इसे कैसे ठीक करें

ऊपर के व्यवहार से दो व्यावहारिक सीख मिलती हैं। पहली, Any के साथ काम करते समय issubclass() से टाइप नैरोइंग की उम्मीद न करें—यह एक ज्ञात सीमा है। दूसरी, जब भी issubclass() कॉल करें, सुनिश्चित करें कि पहला आर्गुमेंट सच में एक प्रकार हो। सबसे सुरक्षित तरीका है issubclass() से पहले isinstance(x, type) का गार्ड लगाना, या अगर आसर्शन जानबूझकर है, तो वेरिएबल को स्पष्ट रूप से type के रूप में annotate करना।

सुधारा हुआ उदाहरण

पहला विकल्प रनटाइम आवश्यकता को खुलकर बताता है और उस तरह से संकुचन बरकरार रखता है जिसे mypy समझता है।

from typing import Any
class BaseUnit:
    pass
def verify(a: Any) -> None:
    if isinstance(a, type) and issubclass(a, BaseUnit):
        reveal_type(a)  # प्रकट किया गया प्रकार "Type[BaseUnit]" है

यदि कोड केवल प्रकारों पर काम करने के लिए बना है, तो शुरुआत में ही वह अनुबंध स्पष्ट कर दें। इससे गलत उपयोग की संभावना घटती है और उद्देश्य साफ रहता है।

class BaseUnit:
    pass
def ensure(b: type) -> None:
    if issubclass(b, BaseUnit):
        pass  # यहाँ b एनोटेशन द्वारा एक टाइप है

यह क्यों महत्वपूर्ण है

Any के साथ टाइप नैरोइंग के लिए issubclass() पर निर्भर रहना झूठी सुरक्षा का अहसास दे सकता है। जाँच रनटाइम पर पास हो सकती है, लेकिन टाइप जानकारी धुंधली ही रहती है, जिससे स्थिर विश्लेषण का लाभ घट जाता है और त्रुटियाँ छिप सकती हैं। साथ ही, गैर-टाइप मान को issubclass() में देना अपवाद उठा सकता है, तो बिना प्रकारों में इसे व्यक्त किए उस कॉल को de facto आसर्शन जैसा मानना कोड को नाज़ुक बना देता है।

मुख्य बातें

यदि कोई मान Any है, तो issubclass() से उसके संकुचन की उम्मीद न करें—यह mypy की ज्ञात सीमा है। issubclass() कॉल करते समय पहले आर्गुमेंट के प्रकार होने की गारंटी दें: या तो isinstance(x, type) का गार्ड जोड़ें, या जहाँ यही अपेक्षित अनुबंध है वहाँ वेरिएबल को type के रूप में annotate करें। ये छोटे समायोजन टाइप चेकर और रनटाइम—दोनों—के व्यवहार को एकसाथ रखते हैं, आश्चर्य कम करते हैं और कोडबेस को समझना आसान बनाते हैं।