tencentcloud-sdk-python 3.0.1419__py2.py3-none-any.whl → 3.0.1421__py2.py3-none-any.whl

tencentcloud/nlp/v20190408/models.py

@@ -574,130 +574,6 @@ class ComposeCoupletResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class ComposePoetryRequest(AbstractModel):
-    """ComposePoetry请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Text: 生成诗词的关键词。
-        :type Text: str
-        :param _PoetryType: 生成诗词的类型。0：藏头或藏身；1：藏头；2：藏身。默认为0。
-        :type PoetryType: int
-        :param _Genre: 诗的体裁。0：五言律诗或七言律诗；5：五言律诗；7：七言律诗。默认为0。
-        :type Genre: int
-        """
-        self._Text = None
-        self._PoetryType = None
-        self._Genre = None
-
-    @property
-    def Text(self):
-        """生成诗词的关键词。
-        :rtype: str
-        """
-        return self._Text
-
-    @Text.setter
-    def Text(self, Text):
-        self._Text = Text
-
-    @property
-    def PoetryType(self):
-        """生成诗词的类型。0：藏头或藏身；1：藏头；2：藏身。默认为0。
-        :rtype: int
-        """
-        return self._PoetryType
-
-    @PoetryType.setter
-    def PoetryType(self, PoetryType):
-        self._PoetryType = PoetryType
-
-    @property
-    def Genre(self):
-        """诗的体裁。0：五言律诗或七言律诗；5：五言律诗；7：七言律诗。默认为0。
-        :rtype: int
-        """
-        return self._Genre
-
-    @Genre.setter
-    def Genre(self, Genre):
-        self._Genre = Genre
-
-
-    def _deserialize(self, params):
-        self._Text = params.get("Text")
-        self._PoetryType = params.get("PoetryType")
-        self._Genre = params.get("Genre")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class ComposePoetryResponse(AbstractModel):
-    """ComposePoetry返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Title: 诗题，即输入的生成诗词的关键词。
-        :type Title: str
-        :param _Content: 诗的内容。
-        :type Content: list of str
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._Title = None
-        self._Content = None
-        self._RequestId = None
-
-    @property
-    def Title(self):
-        """诗题，即输入的生成诗词的关键词。
-        :rtype: str
-        """
-        return self._Title
-
-    @Title.setter
-    def Title(self, Title):
-        self._Title = Title
-
-    @property
-    def Content(self):
-        """诗的内容。
-        :rtype: list of str
-        """
-        return self._Content
-
-    @Content.setter
-    def Content(self, Content):
-        self._Content = Content
-
-    @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :rtype: str
-        """
-        return self._RequestId
-
-    @RequestId.setter
-    def RequestId(self, RequestId):
-        self._RequestId = RequestId
-
-
-    def _deserialize(self, params):
-        self._Title = params.get("Title")
-        self._Content = params.get("Content")
-        self._RequestId = params.get("RequestId")
-
-
 class CompoundParticiple(AbstractModel):
     """复合粒度分词和词性标注的结果。
 
@@ -941,73 +817,6 @@ class CorrectionItem(AbstractModel):
         
 
 
-class Embellish(AbstractModel):
-    """文本润色结果
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Text: 润色后的文本。
-注意：此字段可能返回 null，表示取不到有效值。
-        :type Text: str
-        :param _EmbellishType: 润色类型。类型如下：
-expansion：扩写
-rewriting：改写
-translation_m2a：从现代文改写为古文
-translation_a2m：从古文改写为现代文
-
-
-注意：此字段可能返回 null，表示取不到有效值。
-        :type EmbellishType: str
-        """
-        self._Text = None
-        self._EmbellishType = None
-
-    @property
-    def Text(self):
-        """润色后的文本。
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: str
-        """
-        return self._Text
-
-    @Text.setter
-    def Text(self, Text):
-        self._Text = Text
-
-    @property
-    def EmbellishType(self):
-        """润色类型。类型如下：
-expansion：扩写
-rewriting：改写
-translation_m2a：从现代文改写为古文
-translation_a2m：从古文改写为现代文
-
-
-注意：此字段可能返回 null，表示取不到有效值。
-        :rtype: str
-        """
-        return self._EmbellishType
-
-    @EmbellishType.setter
-    def EmbellishType(self, EmbellishType):
-        self._EmbellishType = EmbellishType
-
-
-    def _deserialize(self, params):
-        self._Text = params.get("Text")
-        self._EmbellishType = params.get("EmbellishType")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
 class Entity(AbstractModel):
     """实体识别结果。
 
@@ -1188,51 +997,32 @@ class EvaluateSentenceSimilarityResponse(AbstractModel):
         self._RequestId = params.get("RequestId")
 
 
-class EvaluateWordSimilarityRequest(AbstractModel):
-    """EvaluateWordSimilarity请求参数结构体
+class ParseWordsRequest(AbstractModel):
+    """ParseWords请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _SourceWord: 计算相似度的源词。（仅支持UTF-8格式，不超过10字符）
-
-        :type SourceWord: str
-        :param _TargetWord: 计算相似度的目标词。（仅支持UTF-8格式，不超过10字符）
-
-        :type TargetWord: str
-        """
-        self._SourceWord = None
-        self._TargetWord = None
-
-    @property
-    def SourceWord(self):
-        """计算相似度的源词。（仅支持UTF-8格式，不超过10字符）
-
-        :rtype: str
+        :param _Text: 待分析的文本（支持中英文文本，不超过500字符）
+        :type Text: str
         """
-        return self._SourceWord
-
-    @SourceWord.setter
-    def SourceWord(self, SourceWord):
-        self._SourceWord = SourceWord
+        self._Text = None
 
     @property
-    def TargetWord(self):
-        """计算相似度的目标词。（仅支持UTF-8格式，不超过10字符）
-
+    def Text(self):
+        """待分析的文本（支持中英文文本，不超过500字符）
         :rtype: str
         """
-        return self._TargetWord
+        return self._Text
 
-    @TargetWord.setter
-    def TargetWord(self, TargetWord):
-        self._TargetWord = TargetWord
+    @Text.setter
+    def Text(self, Text):
+        self._Text = Text
 
 
     def _deserialize(self, params):
-        self._SourceWord = params.get("SourceWord")
-        self._TargetWord = params.get("TargetWord")
+        self._Text = params.get("Text")
         memeber_set = set(params.keys())
         for name, value in vars(self).items():
             property_name = name[1:]
@@ -1243,31 +1033,75 @@ class EvaluateWordSimilarityRequest(AbstractModel):
         
 
 
-class EvaluateWordSimilarityResponse(AbstractModel):
-    """EvaluateWordSimilarity返回参数结构体
+class ParseWordsResponse(AbstractModel):
+    """ParseWords返回参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _Similarity: 词相似度分值。
-        :type Similarity: float
+        :param _NormalText: 输入文本正则化的结果。（包括对英文文本中的开头和实体进行大写等）
+        :type NormalText: str
+        :param _BasicParticiples: 基础粒度分词和词性标注的结果。（请参见附录[词性表](https://cloud.tencent.com/document/product/271/36460)）
+        :type BasicParticiples: list of BasicParticiple
+        :param _CompoundParticiples: 复合粒度分词和词性标注的结果。（请参见附录[词性表](https://cloud.tencent.com/document/product/271/36460)）
+        :type CompoundParticiples: list of CompoundParticiple
+        :param _Entities: 实体识别结果。（请参见附录[实体类型数据](https://cloud.tencent.com/document/product/271/90592)）
+
+        :type Entities: list of Entity
         :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
         :type RequestId: str
         """
-        self._Similarity = None
+        self._NormalText = None
+        self._BasicParticiples = None
+        self._CompoundParticiples = None
+        self._Entities = None
         self._RequestId = None
 
     @property
-    def Similarity(self):
-        """词相似度分值。
-        :rtype: float
+    def NormalText(self):
+        """输入文本正则化的结果。（包括对英文文本中的开头和实体进行大写等）
+        :rtype: str
+        """
+        return self._NormalText
+
+    @NormalText.setter
+    def NormalText(self, NormalText):
+        self._NormalText = NormalText
+
+    @property
+    def BasicParticiples(self):
+        """基础粒度分词和词性标注的结果。（请参见附录[词性表](https://cloud.tencent.com/document/product/271/36460)）
+        :rtype: list of BasicParticiple
+        """
+        return self._BasicParticiples
+
+    @BasicParticiples.setter
+    def BasicParticiples(self, BasicParticiples):
+        self._BasicParticiples = BasicParticiples
+
+    @property
+    def CompoundParticiples(self):
+        """复合粒度分词和词性标注的结果。（请参见附录[词性表](https://cloud.tencent.com/document/product/271/36460)）
+        :rtype: list of CompoundParticiple
+        """
+        return self._CompoundParticiples
+
+    @CompoundParticiples.setter
+    def CompoundParticiples(self, CompoundParticiples):
+        self._CompoundParticiples = CompoundParticiples
+
+    @property
+    def Entities(self):
+        """实体识别结果。（请参见附录[实体类型数据](https://cloud.tencent.com/document/product/271/90592)）
+
+        :rtype: list of Entity
         """
-        return self._Similarity
+        return self._Entities
 
-    @Similarity.setter
-    def Similarity(self, Similarity):
-        self._Similarity = Similarity
+    @Entities.setter
+    def Entities(self, Entities):
+        self._Entities = Entities
 
     @property
     def RequestId(self):
@@ -1282,425 +1116,50 @@ class EvaluateWordSimilarityResponse(AbstractModel):
 
 
     def _deserialize(self, params):
-        self._Similarity = params.get("Similarity")
+        self._NormalText = params.get("NormalText")
+        if params.get("BasicParticiples") is not None:
+            self._BasicParticiples = []
+            for item in params.get("BasicParticiples"):
+                obj = BasicParticiple()
+                obj._deserialize(item)
+                self._BasicParticiples.append(obj)
+        if params.get("CompoundParticiples") is not None:
+            self._CompoundParticiples = []
+            for item in params.get("CompoundParticiples"):
+                obj = CompoundParticiple()
+                obj._deserialize(item)
+                self._CompoundParticiples.append(obj)
+        if params.get("Entities") is not None:
+            self._Entities = []
+            for item in params.get("Entities"):
+                obj = Entity()
+                obj._deserialize(item)
+                self._Entities.append(obj)
         self._RequestId = params.get("RequestId")
 
 
-class GenerateKeywordSentenceRequest(AbstractModel):
-    """GenerateKeywordSentence请求参数结构体
+class SentenceCorrectionRequest(AbstractModel):
+    """SentenceCorrection请求参数结构体
 
     """
 
     def __init__(self):
         r"""
-        :param _WordList: 生成句子的关键词，关键词个数需不超过4个，中文关键词长度应不超过10字符，英文关键词长度不超过3个单词。关键词中不可包含标点符号。
-        :type WordList: list of str
-        :param _Number: 返回生成句子的个数。数量需>=1且<=5。
-（注意实际结果可能小于指定个数）
-        :type Number: int
-        :param _Domain: 指定生成句子的领域，支持领域如下：
-general：通用领域，支持中英文
-academic：学术领域，仅支持英文
-默认为general（通用领域）。
-        :type Domain: str
-        """
-        self._WordList = None
-        self._Number = None
-        self._Domain = None
-
-    @property
-    def WordList(self):
-        """生成句子的关键词，关键词个数需不超过4个，中文关键词长度应不超过10字符，英文关键词长度不超过3个单词。关键词中不可包含标点符号。
-        :rtype: list of str
+        :param _TextList: 待纠错的句子列表。可以以数组方式在一次请求中填写多个待纠错的句子。文本统一使用utf-8格式编码，每个中文句子的长度不超过150字符，每个英文句子的长度不超过100个单词，且数组长度需小于30，即句子总数需少于30句。
+        :type TextList: list of str
         """
-        return self._WordList
-
-    @WordList.setter
-    def WordList(self, WordList):
-        self._WordList = WordList
+        self._TextList = None
 
     @property
-    def Number(self):
-        """返回生成句子的个数。数量需>=1且<=5。
-（注意实际结果可能小于指定个数）
-        :rtype: int
+    def TextList(self):
+        """待纠错的句子列表。可以以数组方式在一次请求中填写多个待纠错的句子。文本统一使用utf-8格式编码，每个中文句子的长度不超过150字符，每个英文句子的长度不超过100个单词，且数组长度需小于30，即句子总数需少于30句。
+        :rtype: list of str
         """
-        return self._Number
+        return self._TextList
 
-    @Number.setter
-    def Number(self, Number):
-        self._Number = Number
-
-    @property
-    def Domain(self):
-        """指定生成句子的领域，支持领域如下：
-general：通用领域，支持中英文
-academic：学术领域，仅支持英文
-默认为general（通用领域）。
-        :rtype: str
-        """
-        return self._Domain
-
-    @Domain.setter
-    def Domain(self, Domain):
-        self._Domain = Domain
-
-
-    def _deserialize(self, params):
-        self._WordList = params.get("WordList")
-        self._Number = params.get("Number")
-        self._Domain = params.get("Domain")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class GenerateKeywordSentenceResponse(AbstractModel):
-    """GenerateKeywordSentence返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _KeywordSentenceList: 生成的句子列表。
-        :type KeywordSentenceList: list of KeywordSentence
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._KeywordSentenceList = None
-        self._RequestId = None
-
-    @property
-    def KeywordSentenceList(self):
-        """生成的句子列表。
-        :rtype: list of KeywordSentence
-        """
-        return self._KeywordSentenceList
-
-    @KeywordSentenceList.setter
-    def KeywordSentenceList(self, KeywordSentenceList):
-        self._KeywordSentenceList = KeywordSentenceList
-
-    @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :rtype: str
-        """
-        return self._RequestId
-
-    @RequestId.setter
-    def RequestId(self, RequestId):
-        self._RequestId = RequestId
-
-
-    def _deserialize(self, params):
-        if params.get("KeywordSentenceList") is not None:
-            self._KeywordSentenceList = []
-            for item in params.get("KeywordSentenceList"):
-                obj = KeywordSentence()
-                obj._deserialize(item)
-                self._KeywordSentenceList.append(obj)
-        self._RequestId = params.get("RequestId")
-
-
-class KeywordSentence(AbstractModel):
-    """通过关键词生成的句子信息
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _TargetText: 通过关键词生成的句子。
-        :type TargetText: str
-        """
-        self._TargetText = None
-
-    @property
-    def TargetText(self):
-        """通过关键词生成的句子。
-        :rtype: str
-        """
-        return self._TargetText
-
-    @TargetText.setter
-    def TargetText(self, TargetText):
-        self._TargetText = TargetText
-
-
-    def _deserialize(self, params):
-        self._TargetText = params.get("TargetText")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class ParseWordsRequest(AbstractModel):
-    """ParseWords请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Text: 待分析的文本（支持中英文文本，不超过500字符）
-        :type Text: str
-        """
-        self._Text = None
-
-    @property
-    def Text(self):
-        """待分析的文本（支持中英文文本，不超过500字符）
-        :rtype: str
-        """
-        return self._Text
-
-    @Text.setter
-    def Text(self, Text):
-        self._Text = Text
-
-
-    def _deserialize(self, params):
-        self._Text = params.get("Text")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class ParseWordsResponse(AbstractModel):
-    """ParseWords返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _NormalText: 输入文本正则化的结果。（包括对英文文本中的开头和实体进行大写等）
-        :type NormalText: str
-        :param _BasicParticiples: 基础粒度分词和词性标注的结果。（请参见附录[词性表](https://cloud.tencent.com/document/product/271/36460)）
-        :type BasicParticiples: list of BasicParticiple
-        :param _CompoundParticiples: 复合粒度分词和词性标注的结果。（请参见附录[词性表](https://cloud.tencent.com/document/product/271/36460)）
-        :type CompoundParticiples: list of CompoundParticiple
-        :param _Entities: 实体识别结果。（请参见附录[实体类型数据](https://cloud.tencent.com/document/product/271/90592)）
-
-        :type Entities: list of Entity
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._NormalText = None
-        self._BasicParticiples = None
-        self._CompoundParticiples = None
-        self._Entities = None
-        self._RequestId = None
-
-    @property
-    def NormalText(self):
-        """输入文本正则化的结果。（包括对英文文本中的开头和实体进行大写等）
-        :rtype: str
-        """
-        return self._NormalText
-
-    @NormalText.setter
-    def NormalText(self, NormalText):
-        self._NormalText = NormalText
-
-    @property
-    def BasicParticiples(self):
-        """基础粒度分词和词性标注的结果。（请参见附录[词性表](https://cloud.tencent.com/document/product/271/36460)）
-        :rtype: list of BasicParticiple
-        """
-        return self._BasicParticiples
-
-    @BasicParticiples.setter
-    def BasicParticiples(self, BasicParticiples):
-        self._BasicParticiples = BasicParticiples
-
-    @property
-    def CompoundParticiples(self):
-        """复合粒度分词和词性标注的结果。（请参见附录[词性表](https://cloud.tencent.com/document/product/271/36460)）
-        :rtype: list of CompoundParticiple
-        """
-        return self._CompoundParticiples
-
-    @CompoundParticiples.setter
-    def CompoundParticiples(self, CompoundParticiples):
-        self._CompoundParticiples = CompoundParticiples
-
-    @property
-    def Entities(self):
-        """实体识别结果。（请参见附录[实体类型数据](https://cloud.tencent.com/document/product/271/90592)）
-
-        :rtype: list of Entity
-        """
-        return self._Entities
-
-    @Entities.setter
-    def Entities(self, Entities):
-        self._Entities = Entities
-
-    @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :rtype: str
-        """
-        return self._RequestId
-
-    @RequestId.setter
-    def RequestId(self, RequestId):
-        self._RequestId = RequestId
-
-
-    def _deserialize(self, params):
-        self._NormalText = params.get("NormalText")
-        if params.get("BasicParticiples") is not None:
-            self._BasicParticiples = []
-            for item in params.get("BasicParticiples"):
-                obj = BasicParticiple()
-                obj._deserialize(item)
-                self._BasicParticiples.append(obj)
-        if params.get("CompoundParticiples") is not None:
-            self._CompoundParticiples = []
-            for item in params.get("CompoundParticiples"):
-                obj = CompoundParticiple()
-                obj._deserialize(item)
-                self._CompoundParticiples.append(obj)
-        if params.get("Entities") is not None:
-            self._Entities = []
-            for item in params.get("Entities"):
-                obj = Entity()
-                obj._deserialize(item)
-                self._Entities.append(obj)
-        self._RequestId = params.get("RequestId")
-
-
-class RetrieveSimilarWordsRequest(AbstractModel):
-    """RetrieveSimilarWords请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Text: 输入的词语。（仅支持UTF-8格式，不超过10字符）
-        :type Text: str
-        :param _Number: 召回的相似词个数，取值范围为1-20。
-        :type Number: int
-        """
-        self._Text = None
-        self._Number = None
-
-    @property
-    def Text(self):
-        """输入的词语。（仅支持UTF-8格式，不超过10字符）
-        :rtype: str
-        """
-        return self._Text
-
-    @Text.setter
-    def Text(self, Text):
-        self._Text = Text
-
-    @property
-    def Number(self):
-        """召回的相似词个数，取值范围为1-20。
-        :rtype: int
-        """
-        return self._Number
-
-    @Number.setter
-    def Number(self, Number):
-        self._Number = Number
-
-
-    def _deserialize(self, params):
-        self._Text = params.get("Text")
-        self._Number = params.get("Number")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class RetrieveSimilarWordsResponse(AbstractModel):
-    """RetrieveSimilarWords返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _WordList: 召回的相似词数组。
-        :type WordList: list of str
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._WordList = None
-        self._RequestId = None
-
-    @property
-    def WordList(self):
-        """召回的相似词数组。
-        :rtype: list of str
-        """
-        return self._WordList
-
-    @WordList.setter
-    def WordList(self, WordList):
-        self._WordList = WordList
-
-    @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :rtype: str
-        """
-        return self._RequestId
-
-    @RequestId.setter
-    def RequestId(self, RequestId):
-        self._RequestId = RequestId
-
-
-    def _deserialize(self, params):
-        self._WordList = params.get("WordList")
-        self._RequestId = params.get("RequestId")
-
-
-class SentenceCorrectionRequest(AbstractModel):
-    """SentenceCorrection请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _TextList: 待纠错的句子列表。可以以数组方式在一次请求中填写多个待纠错的句子。文本统一使用utf-8格式编码，每个中文句子的长度不超过150字符，每个英文句子的长度不超过100个单词，且数组长度需小于30，即句子总数需少于30句。
-        :type TextList: list of str
-        """
-        self._TextList = None
-
-    @property
-    def TextList(self):
-        """待纠错的句子列表。可以以数组方式在一次请求中填写多个待纠错的句子。文本统一使用utf-8格式编码，每个中文句子的长度不超过150字符，每个英文句子的长度不超过100个单词，且数组长度需小于30，即句子总数需少于30句。
-        :rtype: list of str
-        """
-        return self._TextList
-
-    @TextList.setter
-    def TextList(self, TextList):
-        self._TextList = TextList
+    @TextList.setter
+    def TextList(self, TextList):
+        self._TextList = TextList
 
 
     def _deserialize(self, params):
@@ -1815,368 +1274,4 @@ class SentencePair(AbstractModel):
                 memeber_set.remove(property_name)
         if len(memeber_set) > 0:
             warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class TextEmbellishRequest(AbstractModel):
-    """TextEmbellish请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Text: 待润色的文本。中文文本长度需<=50字符；英文文本长度需<=30个单词。
-        :type Text: str
-        :param _SourceLang: 待润色文本的语言类型，支持语言如下：
-zh：中文
-en：英文
-        :type SourceLang: str
-        :param _Number: 返回润色结果的个数。数量需>=1且<=5。
-（注意实际结果可能小于指定个数）
-        :type Number: int
-        :param _Style: 控制润色类型，类型如下：
-both：同时返回改写和扩写
-expansion：扩写
-rewriting：改写
-m2a：从现代文改写为古文
-a2m：从古文改写为现代文
-默认为both。
-        :type Style: str
-        """
-        self._Text = None
-        self._SourceLang = None
-        self._Number = None
-        self._Style = None
-
-    @property
-    def Text(self):
-        """待润色的文本。中文文本长度需<=50字符；英文文本长度需<=30个单词。
-        :rtype: str
-        """
-        return self._Text
-
-    @Text.setter
-    def Text(self, Text):
-        self._Text = Text
-
-    @property
-    def SourceLang(self):
-        """待润色文本的语言类型，支持语言如下：
-zh：中文
-en：英文
-        :rtype: str
-        """
-        return self._SourceLang
-
-    @SourceLang.setter
-    def SourceLang(self, SourceLang):
-        self._SourceLang = SourceLang
-
-    @property
-    def Number(self):
-        """返回润色结果的个数。数量需>=1且<=5。
-（注意实际结果可能小于指定个数）
-        :rtype: int
-        """
-        return self._Number
-
-    @Number.setter
-    def Number(self, Number):
-        self._Number = Number
-
-    @property
-    def Style(self):
-        """控制润色类型，类型如下：
-both：同时返回改写和扩写
-expansion：扩写
-rewriting：改写
-m2a：从现代文改写为古文
-a2m：从古文改写为现代文
-默认为both。
-        :rtype: str
-        """
-        return self._Style
-
-    @Style.setter
-    def Style(self, Style):
-        self._Style = Style
-
-
-    def _deserialize(self, params):
-        self._Text = params.get("Text")
-        self._SourceLang = params.get("SourceLang")
-        self._Number = params.get("Number")
-        self._Style = params.get("Style")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class TextEmbellishResponse(AbstractModel):
-    """TextEmbellish返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _EmbellishList: 润色结果列表。
-        :type EmbellishList: list of Embellish
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._EmbellishList = None
-        self._RequestId = None
-
-    @property
-    def EmbellishList(self):
-        """润色结果列表。
-        :rtype: list of Embellish
-        """
-        return self._EmbellishList
-
-    @EmbellishList.setter
-    def EmbellishList(self, EmbellishList):
-        self._EmbellishList = EmbellishList
-
-    @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :rtype: str
-        """
-        return self._RequestId
-
-    @RequestId.setter
-    def RequestId(self, RequestId):
-        self._RequestId = RequestId
-
-
-    def _deserialize(self, params):
-        if params.get("EmbellishList") is not None:
-            self._EmbellishList = []
-            for item in params.get("EmbellishList"):
-                obj = Embellish()
-                obj._deserialize(item)
-                self._EmbellishList.append(obj)
-        self._RequestId = params.get("RequestId")
-
-
-class TextWritingRequest(AbstractModel):
-    """TextWriting请求参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _Text: 待续写的句子，文本统一使用utf-8格式编码，长度不超过200字符。
-        :type Text: str
-        :param _SourceLang: 待续写文本的语言类型，支持语言如下：
-zh：中文
-en：英文
-        :type SourceLang: str
-        :param _Number: 返回续写结果的个数。数量需>=1且<=5。
-（注意实际结果可能小于指定个数）
-        :type Number: int
-        :param _Domain: 指定续写领域，支持领域如下：
-general：通用领域，支持中英文补全
-academic：学术领域，仅支持英文补全
-默认为general（通用领域）。
-        :type Domain: str
-        :param _Style: 指定续写风格，支持风格如下：
-science_fiction：科幻
-military_history：军事
-xuanhuan_wuxia：武侠
-urban_officialdom：职场
-默认为xuanhuan_wuxia（武侠）。
-        :type Style: str
-        """
-        self._Text = None
-        self._SourceLang = None
-        self._Number = None
-        self._Domain = None
-        self._Style = None
-
-    @property
-    def Text(self):
-        """待续写的句子，文本统一使用utf-8格式编码，长度不超过200字符。
-        :rtype: str
-        """
-        return self._Text
-
-    @Text.setter
-    def Text(self, Text):
-        self._Text = Text
-
-    @property
-    def SourceLang(self):
-        """待续写文本的语言类型，支持语言如下：
-zh：中文
-en：英文
-        :rtype: str
-        """
-        return self._SourceLang
-
-    @SourceLang.setter
-    def SourceLang(self, SourceLang):
-        self._SourceLang = SourceLang
-
-    @property
-    def Number(self):
-        """返回续写结果的个数。数量需>=1且<=5。
-（注意实际结果可能小于指定个数）
-        :rtype: int
-        """
-        return self._Number
-
-    @Number.setter
-    def Number(self, Number):
-        self._Number = Number
-
-    @property
-    def Domain(self):
-        """指定续写领域，支持领域如下：
-general：通用领域，支持中英文补全
-academic：学术领域，仅支持英文补全
-默认为general（通用领域）。
-        :rtype: str
-        """
-        return self._Domain
-
-    @Domain.setter
-    def Domain(self, Domain):
-        self._Domain = Domain
-
-    @property
-    def Style(self):
-        """指定续写风格，支持风格如下：
-science_fiction：科幻
-military_history：军事
-xuanhuan_wuxia：武侠
-urban_officialdom：职场
-默认为xuanhuan_wuxia（武侠）。
-        :rtype: str
-        """
-        return self._Style
-
-    @Style.setter
-    def Style(self, Style):
-        self._Style = Style
-
-
-    def _deserialize(self, params):
-        self._Text = params.get("Text")
-        self._SourceLang = params.get("SourceLang")
-        self._Number = params.get("Number")
-        self._Domain = params.get("Domain")
-        self._Style = params.get("Style")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
-        
-
-
-class TextWritingResponse(AbstractModel):
-    """TextWriting返回参数结构体
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _WritingList: 续写结果列表。
-        :type WritingList: list of Writing
-        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :type RequestId: str
-        """
-        self._WritingList = None
-        self._RequestId = None
-
-    @property
-    def WritingList(self):
-        """续写结果列表。
-        :rtype: list of Writing
-        """
-        return self._WritingList
-
-    @WritingList.setter
-    def WritingList(self, WritingList):
-        self._WritingList = WritingList
-
-    @property
-    def RequestId(self):
-        """唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
-        :rtype: str
-        """
-        return self._RequestId
-
-    @RequestId.setter
-    def RequestId(self, RequestId):
-        self._RequestId = RequestId
-
-
-    def _deserialize(self, params):
-        if params.get("WritingList") is not None:
-            self._WritingList = []
-            for item in params.get("WritingList"):
-                obj = Writing()
-                obj._deserialize(item)
-                self._WritingList.append(obj)
-        self._RequestId = params.get("RequestId")
-
-
-class Writing(AbstractModel):
-    """文本续写结果
-
-    """
-
-    def __init__(self):
-        r"""
-        :param _TargetText: 续写的文本。
-        :type TargetText: str
-        :param _PrefixText: 续写的前缀。
-        :type PrefixText: str
-        """
-        self._TargetText = None
-        self._PrefixText = None
-
-    @property
-    def TargetText(self):
-        """续写的文本。
-        :rtype: str
-        """
-        return self._TargetText
-
-    @TargetText.setter
-    def TargetText(self, TargetText):
-        self._TargetText = TargetText
-
-    @property
-    def PrefixText(self):
-        """续写的前缀。
-        :rtype: str
-        """
-        return self._PrefixText
-
-    @PrefixText.setter
-    def PrefixText(self, PrefixText):
-        self._PrefixText = PrefixText
-
-
-    def _deserialize(self, params):
-        self._TargetText = params.get("TargetText")
-        self._PrefixText = params.get("PrefixText")
-        memeber_set = set(params.keys())
-        for name, value in vars(self).items():
-            property_name = name[1:]
-            if property_name in memeber_set:
-                memeber_set.remove(property_name)
-        if len(memeber_set) > 0:
-            warnings.warn("%s fileds are useless." % ",".join(memeber_set))