ignore protected fields

pydantic-pycharm-plugin.iml

@@ -15,7 +15,7 @@
       <sourceFolder url="file://$MODULE_DIR$/testData" type="java-test-resource" />
       <excludePattern pattern="out" />
     </content>
-    <orderEntry type="jdk" jdkName="JavaSDK" jdkType="IDEA JDK" />
+    <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="Python 3.7 (pydantic-pycharm-plugin) interpreter library" level="application" />
   </component>

resources/META-INF/plugin.xml

@@ -1,9 +1,14 @@
 <idea-plugin url="https://github.com/koxudaxi/pydantic-pycharm-plugin">
     <id>com.koxudaxi.pydantic</id>
     <name>Pydantic</name>
-    <version>0.0.21</version>
+    <version>0.0.23</version>
     <vendor email="koaxudai@gmail.com">Koudai Aono @koxudaxi</vendor>
     <change-notes><![CDATA[
+    <h2>version 0.0.23</h2>
+    <p>Features</p>
+    <ul>
+        <li>Ignore protected and private fields [#79] </li>
+    </ul>
     <h2>version 0.0.22</h2>
     <p>Features, BugFixes</p>
     <ul>

src/com/koxudaxi/pydantic/Pydantic.kt

@@ -114,7 +114,7 @@ internal fun getAliasedFieldName(field: PyTargetExpression, context: TypeEvalCon
                 if (versionZero) {
                     isPydanticSchemaByPsiElement(it, context)
                 } else {
-                    isPydanticFieldByPsiElement(it, context)
+                    isPydanticFieldByPsiElement(it)
                 }
 
             }
@@ -164,7 +164,7 @@ internal fun isPydanticSchemaByPsiElement(psiElement: PsiElement, context: TypeE
     return false
 }
 
-internal fun isPydanticFieldByPsiElement(psiElement: PsiElement, context: TypeEvalContext): Boolean {
+internal fun isPydanticFieldByPsiElement(psiElement: PsiElement): Boolean {
     when (psiElement) {
         is PyFunction -> return isPydanticField(psiElement)
         else -> PsiTreeUtil.getContextOfType(psiElement, PyFunction::class.java)
@@ -190,4 +190,8 @@ internal fun getPydanticVersion(project: Project, context: TypeEvalContext): Kot
         pydanticVersionCache[versionString] = pydanticVersion
         pydanticVersion
     })
+}
+
+internal fun isValidFieldName(name: String): Boolean {
+    return name.first() != '_'
 }

src/com/koxudaxi/pydantic/PydanticCompletionContributor.kt

@@ -64,6 +64,7 @@ class PydanticCompletionContributor : CompletionContributor() {
             val pydanticVersion = getPydanticVersion(pyClass.project, typeEvalContext)
             getClassVariables(pyClass, typeEvalContext)
                     .filter { it.name != null }
+                    .filter {isValidFieldName(it.name!!)}
                     .forEach {
                         val elementName = getLookupNameFromFieldName(it, typeEvalContext, pydanticVersion)
                         if (excludes == null || !excludes.contains(elementName)) {
@@ -109,10 +110,17 @@ class PydanticCompletionContributor : CompletionContributor() {
 
             pyClass.getAncestorClasses(typeEvalContext)
                     .filter { isPydanticModel(it) }
-                    .forEach { fieldElements.addAll(it.classAttributes.mapNotNull { attribute -> attribute?.name }) }
+                    .forEach { fieldElements.addAll(it.classAttributes
+                            .filter {attribute
+                                -> attribute.name?.let { name -> isValidFieldName(name)} ?: false}
+                            .mapNotNull { attribute -> attribute?.name }) }
 
 
-            fieldElements.addAll(pyClass.classAttributes.mapNotNull { attribute -> attribute?.name })
+
+            fieldElements.addAll(pyClass.classAttributes
+                    .filter {attribute
+                        -> attribute.name?.let { name -> isValidFieldName(name)} ?: false}
+                    .mapNotNull { attribute -> attribute?.name })
 
             result.runRemainingContributors(parameters)
             { completionResult ->

src/com/koxudaxi/pydantic/PydanticTypeProvider.kt

@@ -132,7 +132,7 @@ class PydanticTypeProvider : PyTypeProviderBase() {
                                   context: TypeEvalContext,
                                   pyClass: PyClass,
                                   pydanticVersion: KotlinVersion?): PyCallableParameter? {
-
+        if (field.name == null || ! isValidFieldName(field.name!!)) return null
         if (!hasAnnotationValue(field) && !field.hasAssignedValue()) return null // skip fields that are invalid syntax
 
         val defaultValueFromField = getDefaultValueForParameter(field, ellipsis, context, pydanticVersion)
@@ -203,7 +203,7 @@ class PydanticTypeProvider : PyTypeProviderBase() {
                 .any {
                     when {
                         versionZero -> isPydanticSchemaByPsiElement(it, context)
-                        else -> isPydanticFieldByPsiElement(it, context)
+                        else -> isPydanticFieldByPsiElement(it)
                     }
 
                 }

testData/completion/fieldIgnore.py

@@ -0,0 +1,14 @@
+from builtins import *
+from pydantic import BaseModel
+
+
+class A(BaseModel):
+    _abc: str = str('abc')
+    __cde: str = str('abc')
+
+
+class B(A):
+    _efg: str = str('abc')
+    __hij: str = str('abc')
+
+A().<caret>

testData/completion/keywordArgumentIgnore.py

@@ -0,0 +1,15 @@
+from builtins import *
+
+from pydantic import BaseModel
+
+
+class A(BaseModel):
+    _abc: str = str('abc')
+    __cde: str = str('abc')
+
+
+class B(A):
+    _efg: str = str('abc')
+    __hij: str = str('abc')
+
+B(<caret>)

testSrc/com/koxudaxi/pydantic/PydanticCompletionTest.kt

@@ -29,6 +29,13 @@ open class PydanticCompletionTest : PydanticTestCase() {
         )
     }
 
+    fun testKeywordArgumentIgnore() {
+        doFieldTest(
+                listOf(
+                )
+        )
+    }
+
     fun testKeywordArgumentParent() {
         doFieldTest(
                 listOf(
@@ -344,6 +351,14 @@ open class PydanticCompletionTest : PydanticTestCase() {
         )
     }
 
+    fun testFieldIgnore() {
+        doFieldTest(
+                listOf(
+                        Pair("___slots__", "BaseModel")
+                )
+        )
+    }
+
     fun testFieldOptional() {
         doFieldTest(
                 listOf(