ngram
sequencelengths 0
82k
|
|---|
[
"class Meta: fields = ( \"id\", \"couverture\", \"usage\", \"millesime\", \"map_color\",",
"( \"nom\", \"code_insee\", \"surface\", ) geo_field = \"mpoly\" model =",
"\"surface\", ) geo_field = \"mpoly\" model = ZonesBaties2018 class CouvertureSolSerializer(serializers.ModelSerializer):",
"GeoJSON serializer.\"\"\" class Meta: \"\"\"Marker serializer meta class.\"\"\" fields =",
"\"label\", \"is_artificial\", ) model = CouvertureSol class UsageSolSerializer(serializers.ModelSerializer): class Meta:",
"label=obj.couverture_label) def get_usage(self, obj): return get_label(code=obj.usage, label=obj.usage_label) class Meta: fields",
"get_label(code=obj.couverture, label=obj.couverture_label) class Meta: fields = ( \"id\", \"couverture\", \"surface\",",
"geo_field = \"mpoly\" model = Artificialisee2015to2018 class Artificielle2018Serializer(serializers.GeoFeatureModelSerializer): couverture =",
"= Voirie2018 class ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField()",
"\"inconnu\" return f\"{code} {label[:30]}\" class Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018",
"( \"id\", \"surface\", ) geo_field = \"mpoly\" model = Sybarval",
"serializers from rest_framework import serializers as s from .models import",
"return get_label(code=obj.cs_2018, label=obj.cs_2018_label) class Meta: fields = ( \"id\", \"surface\",",
"obj): return get_label(code=obj.us_2018, label=obj.us_2018_label) def get_couverture_2015(self, obj): return get_label(code=obj.cs_2015, label=obj.cs_2015_label)",
"model = Artificielle2018 class CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer): \"\"\"Marker GeoJSON serializer.\"\"\" class Meta:",
"usage = s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) def",
"geo_field = \"mpoly\" model = Ocsge class Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer): usage_2015 =",
"\"usage_2018\", \"couverture_2015\", \"couverture_2018\", ) geo_field = \"mpoly\" model = Renaturee2018to2015",
"\"couverture\", \"usage\", ) geo_field = \"mpoly\" model = Voirie2018 class",
"return get_label(code=obj.usage, label=obj.usage_label) class Meta: fields = ( \"id\", \"surface\",",
"s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) class Meta: fields",
"geo_field = \"mpoly\" model = EnveloppeUrbaine2018 class OcsgeSerializer(serializers.GeoFeatureModelSerializer): couverture =",
"couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def get_couverture(self, obj): return",
"\"id\", \"surface\", \"usage_2015\", \"usage_2018\", \"couverture_2015\", \"couverture_2018\", ) geo_field = \"mpoly\"",
"= ZonesBaties2018 class CouvertureSolSerializer(serializers.ModelSerializer): class Meta: fields = ( \"id\",",
"class Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 = s.SerializerMethodField() couverture_2015 =",
"return get_label(code=obj.usage, label=obj.usage_label) class Meta: fields = ( \"id\", \"couverture\",",
"geo_field = \"mpoly\" model = Voirie2018 class ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer): couverture =",
"Artificialisee2015to2018, Artificielle2018, CommunesSybarval, CouvertureSol, EnveloppeUrbaine2018, Ocsge, Renaturee2018to2015, Sybarval, Voirie2018, ZonesBaties2018,",
"obj): return get_label(code=obj.couverture, label=obj.couverture_label) class Meta: fields = ( \"id\",",
"get_label(code=obj.couverture, label=obj.couverture_label) def get_usage(self, obj): return get_label(code=obj.usage, label=obj.usage_label) class Meta:",
"\"mpoly\" model = Voirie2018 class ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage",
"\"usage\", \"surface\", ) geo_field = \"mpoly\" model = ZonesBaties2018 class",
"CouvertureSolSerializer(serializers.ModelSerializer): class Meta: fields = ( \"id\", \"parent\", \"code\", \"label\",",
"geo_field = \"mpoly\" model = Artificielle2018 class CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer): \"\"\"Marker GeoJSON",
"model = ZonesBaties2018 class CouvertureSolSerializer(serializers.ModelSerializer): class Meta: fields = (",
"= s.SerializerMethodField() def get_usage_2015(self, obj): return get_label(code=obj.us_2015, label=obj.us_2015_label) def get_usage_2018(self,",
"= s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) def get_usage(self,",
") geo_field = \"mpoly\" model = EnveloppeUrbaine2018 class OcsgeSerializer(serializers.GeoFeatureModelSerializer): couverture",
"label=obj.usage_label) class Meta: fields = ( \"id\", \"couverture\", \"usage\", \"millesime\",",
"Meta: fields = ( \"id\", \"surface\", ) geo_field = \"mpoly\"",
"class ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def get_couverture(self,",
") geo_field = \"mpoly\" model = ZonesBaties2018 class CouvertureSolSerializer(serializers.ModelSerializer): class",
"class CouvertureSolSerializer(serializers.ModelSerializer): class Meta: fields = ( \"id\", \"parent\", \"code\",",
"fields = ( \"id\", \"parent\", \"code\", \"label\", \"is_artificial\", ) model",
"class Meta: fields = ( \"id\", \"surface\", \"couverture\", \"usage\", )",
"Meta: fields = ( \"id\", \"parent\", \"code\", \"label\", \"is_artificial\", )",
"\"mpoly\" model = CommunesSybarval class EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def",
"s.SerializerMethodField() usage_2018 = s.SerializerMethodField() couverture_2015 = s.SerializerMethodField() couverture_2018 = s.SerializerMethodField()",
"\"id\", \"parent\", \"code\", \"label\", \"is_artificial\", ) model = CouvertureSol class",
"class Meta: \"\"\"Marker serializer meta class.\"\"\" fields = ( \"nom\",",
"get_usage(self, obj): return get_label(code=obj.usage, label=obj.usage_label) class Meta: fields = (",
"return get_label(code=obj.couverture, label=obj.couverture_label) def get_usage(self, obj): return get_label(code=obj.usage, label=obj.usage_label) class",
"( \"id\", \"surface\", \"couverture\", ) geo_field = \"mpoly\" model =",
"OcsgeSerializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def get_couverture(self, obj):",
"\"couverture\", \"usage\", \"millesime\", \"map_color\", \"year\", ) geo_field = \"mpoly\" model",
"fields = ( \"id\", \"surface\", ) geo_field = \"mpoly\" model",
"UsageSolSerializer(serializers.ModelSerializer): class Meta: fields = ( \"id\", \"parent\", \"code\", \"label\",",
"\"id\", \"couverture\", \"usage\", \"millesime\", \"map_color\", \"year\", ) geo_field = \"mpoly\"",
"label=\"\"): if code is None: code = \"-\" if label",
"Artificielle2018 class CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer): \"\"\"Marker GeoJSON serializer.\"\"\" class Meta: \"\"\"Marker serializer",
"None: label = \"inconnu\" return f\"{code} {label[:30]}\" class Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer): usage_2015",
"\"couverture_2015\", \"couverture_2018\", ) geo_field = \"mpoly\" model = Artificialisee2015to2018 class",
"\"surface\", \"couverture\", \"usage\", ) geo_field = \"mpoly\" model = Voirie2018",
"get_couverture_2018(self, obj): return get_label(code=obj.cs_2018, label=obj.cs_2018_label) class Meta: fields = (",
"fields = ( \"id\", \"couverture\", \"usage\", \"millesime\", \"map_color\", \"year\", )",
"fields = ( \"id\", \"surface\", \"usage_2015\", \"usage_2018\", \"couverture_2015\", \"couverture_2018\", )",
"CouvertureSol class UsageSolSerializer(serializers.ModelSerializer): class Meta: fields = ( \"id\", \"parent\",",
"s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) def get_usage(self, obj):",
"label=obj.usage_label) class Meta: fields = ( \"id\", \"surface\", \"couverture\", \"usage\",",
"def get_usage(self, obj): return get_label(code=obj.usage, label=obj.usage_label) class Meta: fields =",
"if code is None: code = \"-\" if label is",
"meta class.\"\"\" fields = ( \"nom\", \"code_insee\", \"surface\", ) geo_field",
"Meta: fields = ( \"id\", \"surface\", \"couverture\", \"usage\", ) geo_field",
"<reponame>MTES-MCT/sparte from rest_framework_gis import serializers from rest_framework import serializers as",
"import serializers as s from .models import ( Artificialisee2015to2018, Artificielle2018,",
"Voirie2018, ZonesBaties2018, UsageSol, ) def get_label(code=\"\", label=\"\"): if code is",
"get_label(code=obj.cs_2015, label=obj.cs_2015_label) def get_couverture_2018(self, obj): return get_label(code=obj.cs_2018, label=obj.cs_2018_label) class Meta:",
"return get_label(code=obj.us_2018, label=obj.us_2018_label) def get_couverture_2015(self, obj): return get_label(code=obj.cs_2015, label=obj.cs_2015_label) def",
"Voirie2018 class ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def",
"\"mpoly\" model = Artificielle2018 class CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer): \"\"\"Marker GeoJSON serializer.\"\"\" class",
"fields = ( \"nom\", \"code_insee\", \"surface\", ) geo_field = \"mpoly\"",
"\"id\", \"surface\", \"couverture\", \"usage\", ) geo_field = \"mpoly\" model =",
"label=obj.usage_label) class Meta: fields = ( \"id\", \"couverture\", \"usage\", \"surface\",",
"\"mpoly\" model = ZonesBaties2018 class CouvertureSolSerializer(serializers.ModelSerializer): class Meta: fields =",
"\"couverture\", ) geo_field = \"mpoly\" model = Artificielle2018 class CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer):",
".models import ( Artificialisee2015to2018, Artificielle2018, CommunesSybarval, CouvertureSol, EnveloppeUrbaine2018, Ocsge, Renaturee2018to2015,",
"Artificielle2018, CommunesSybarval, CouvertureSol, EnveloppeUrbaine2018, Ocsge, Renaturee2018to2015, Sybarval, Voirie2018, ZonesBaties2018, UsageSol,",
"= \"inconnu\" return f\"{code} {label[:30]}\" class Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField()",
"label=obj.cs_2015_label) def get_couverture_2018(self, obj): return get_label(code=obj.cs_2018, label=obj.cs_2018_label) class Meta: fields",
"= s.SerializerMethodField() couverture_2015 = s.SerializerMethodField() couverture_2018 = s.SerializerMethodField() def get_usage_2015(self,",
"\"couverture_2018\", ) geo_field = \"mpoly\" model = Renaturee2018to2015 class SybarvalSerializer(serializers.GeoFeatureModelSerializer):",
"= \"mpoly\" model = Artificialisee2015to2018 class Artificielle2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField()",
"\"id\", \"surface\", ) geo_field = \"mpoly\" model = Sybarval class",
"Meta: \"\"\"Marker serializer meta class.\"\"\" fields = ( \"nom\", \"code_insee\",",
"model = Sybarval class Voirie2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage =",
"CommunesSybarval, CouvertureSol, EnveloppeUrbaine2018, Ocsge, Renaturee2018to2015, Sybarval, Voirie2018, ZonesBaties2018, UsageSol, )",
"\"is_artificial\", ) model = CouvertureSol class UsageSolSerializer(serializers.ModelSerializer): class Meta: fields",
"fields = ( \"id\", \"surface\", \"couverture\", \"usage\", ) geo_field =",
"= ( \"id\", \"surface\", \"couverture\", \"usage\", ) geo_field = \"mpoly\"",
"def get_usage_2018(self, obj): return get_label(code=obj.us_2018, label=obj.us_2018_label) def get_couverture_2015(self, obj): return",
"= s.SerializerMethodField() usage_2018 = s.SerializerMethodField() couverture_2015 = s.SerializerMethodField() couverture_2018 =",
"class OcsgeSerializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def get_couverture(self,",
"Voirie2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def get_couverture(self, obj):",
"\"surface\", ) geo_field = \"mpoly\" model = CommunesSybarval class EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer):",
"obj): return get_label(code=obj.cs_2015, label=obj.cs_2015_label) def get_couverture_2018(self, obj): return get_label(code=obj.cs_2018, label=obj.cs_2018_label)",
"label=obj.couverture_label) class Meta: fields = ( \"id\", \"couverture\", \"surface\", )",
"obj): return get_label(code=obj.couverture, label=obj.couverture_label) def get_usage(self, obj): return get_label(code=obj.usage, label=obj.usage_label)",
") def get_label(code=\"\", label=\"\"): if code is None: code =",
"\"couverture\", \"surface\", ) geo_field = \"mpoly\" model = EnveloppeUrbaine2018 class",
"Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 = s.SerializerMethodField() couverture_2015 = s.SerializerMethodField()",
"( Artificialisee2015to2018, Artificielle2018, CommunesSybarval, CouvertureSol, EnveloppeUrbaine2018, Ocsge, Renaturee2018to2015, Sybarval, Voirie2018,",
") geo_field = \"mpoly\" model = CommunesSybarval class EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer): couverture",
"\"mpoly\" model = Sybarval class Voirie2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage",
") model = CouvertureSol class UsageSolSerializer(serializers.ModelSerializer): class Meta: fields =",
"class Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 = s.SerializerMethodField() couverture_2015 =",
"= s.SerializerMethodField() usage = s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture,",
"get_label(code=obj.usage, label=obj.usage_label) class Meta: fields = ( \"id\", \"surface\", \"couverture\",",
"s.SerializerMethodField() couverture_2018 = s.SerializerMethodField() def get_usage_2015(self, obj): return get_label(code=obj.us_2015, label=obj.us_2015_label)",
"label=obj.cs_2018_label) class Meta: fields = ( \"id\", \"surface\", \"usage_2015\", \"usage_2018\",",
"geo_field = \"mpoly\" model = Sybarval class Voirie2018Serializer(serializers.GeoFeatureModelSerializer): couverture =",
"= \"-\" if label is None: label = \"inconnu\" return",
"fields = ( \"id\", \"surface\", \"couverture\", ) geo_field = \"mpoly\"",
"None: code = \"-\" if label is None: label =",
"= ( \"id\", \"surface\", ) geo_field = \"mpoly\" model =",
"def get_label(code=\"\", label=\"\"): if code is None: code = \"-\"",
"Ocsge class Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 = s.SerializerMethodField() couverture_2015",
"def get_usage_2015(self, obj): return get_label(code=obj.us_2015, label=obj.us_2015_label) def get_usage_2018(self, obj): return",
"= EnveloppeUrbaine2018 class OcsgeSerializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField()",
"couverture_2018 = s.SerializerMethodField() def get_usage_2015(self, obj): return get_label(code=obj.us_2015, label=obj.us_2015_label) def",
"CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer): \"\"\"Marker GeoJSON serializer.\"\"\" class Meta: \"\"\"Marker serializer meta class.\"\"\"",
"class Meta: fields = ( \"id\", \"couverture\", \"surface\", ) geo_field",
"\"usage\", \"millesime\", \"map_color\", \"year\", ) geo_field = \"mpoly\" model =",
"class SybarvalSerializer(serializers.GeoFeatureModelSerializer): class Meta: fields = ( \"id\", \"surface\", )",
"class Meta: fields = ( \"id\", \"parent\", \"code\", \"label\", \"is_artificial\",",
"class Meta: fields = ( \"id\", \"couverture\", \"usage\", \"surface\", )",
"rest_framework_gis import serializers from rest_framework import serializers as s from",
"return f\"{code} {label[:30]}\" class Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 =",
"rest_framework import serializers as s from .models import ( Artificialisee2015to2018,",
"= ( \"nom\", \"code_insee\", \"surface\", ) geo_field = \"mpoly\" model",
"from rest_framework_gis import serializers from rest_framework import serializers as s",
"( \"id\", \"surface\", \"usage_2015\", \"usage_2018\", \"couverture_2015\", \"couverture_2018\", ) geo_field =",
"def get_couverture_2018(self, obj): return get_label(code=obj.cs_2018, label=obj.cs_2018_label) class Meta: fields =",
"label=obj.us_2015_label) def get_usage_2018(self, obj): return get_label(code=obj.us_2018, label=obj.us_2018_label) def get_couverture_2015(self, obj):",
"Ocsge, Renaturee2018to2015, Sybarval, Voirie2018, ZonesBaties2018, UsageSol, ) def get_label(code=\"\", label=\"\"):",
"geo_field = \"mpoly\" model = CommunesSybarval class EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer): couverture =",
"return get_label(code=obj.couverture, label=obj.couverture_label) class Meta: fields = ( \"id\", \"couverture\",",
"\"couverture_2015\", \"couverture_2018\", ) geo_field = \"mpoly\" model = Renaturee2018to2015 class",
"model = CouvertureSol class UsageSolSerializer(serializers.ModelSerializer): class Meta: fields = (",
") geo_field = \"mpoly\" model = Artificielle2018 class CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer): \"\"\"Marker",
"\"surface\", ) geo_field = \"mpoly\" model = EnveloppeUrbaine2018 class OcsgeSerializer(serializers.GeoFeatureModelSerializer):",
"is None: label = \"inconnu\" return f\"{code} {label[:30]}\" class Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer):",
"couverture_2015 = s.SerializerMethodField() couverture_2018 = s.SerializerMethodField() def get_usage_2015(self, obj): return",
"= s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) class Meta:",
"\"mpoly\" model = Renaturee2018to2015 class SybarvalSerializer(serializers.GeoFeatureModelSerializer): class Meta: fields =",
"= ( \"id\", \"couverture\", \"usage\", \"surface\", ) geo_field = \"mpoly\"",
"= Artificielle2018 class CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer): \"\"\"Marker GeoJSON serializer.\"\"\" class Meta: \"\"\"Marker",
"= ( \"id\", \"couverture\", \"usage\", \"millesime\", \"map_color\", \"year\", ) geo_field",
"EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label)",
"is None: code = \"-\" if label is None: label",
"Meta: fields = ( \"id\", \"couverture\", \"usage\", \"surface\", ) geo_field",
"class Meta: fields = ( \"id\", \"parent\", \"code\", \"label\", )",
") geo_field = \"mpoly\" model = Voirie2018 class ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer): couverture",
"label=obj.couverture_label) class Meta: fields = ( \"id\", \"surface\", \"couverture\", )",
"usage_2018 = s.SerializerMethodField() couverture_2015 = s.SerializerMethodField() couverture_2018 = s.SerializerMethodField() def",
"serializers as s from .models import ( Artificialisee2015to2018, Artificielle2018, CommunesSybarval,",
"Meta: fields = ( \"id\", \"couverture\", \"usage\", \"millesime\", \"map_color\", \"year\",",
"\"id\", \"couverture\", \"surface\", ) geo_field = \"mpoly\" model = EnveloppeUrbaine2018",
"= \"mpoly\" model = Voirie2018 class ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField()",
"SybarvalSerializer(serializers.GeoFeatureModelSerializer): class Meta: fields = ( \"id\", \"surface\", ) geo_field",
"Meta: fields = ( \"id\", \"surface\", \"couverture\", ) geo_field =",
"couverture = s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) class",
"( \"id\", \"couverture\", \"usage\", \"millesime\", \"map_color\", \"year\", ) geo_field =",
") geo_field = \"mpoly\" model = Artificialisee2015to2018 class Artificielle2018Serializer(serializers.GeoFeatureModelSerializer): couverture",
"obj): return get_label(code=obj.usage, label=obj.usage_label) class Meta: fields = ( \"id\",",
"s.SerializerMethodField() usage = s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label)",
"from .models import ( Artificialisee2015to2018, Artificielle2018, CommunesSybarval, CouvertureSol, EnveloppeUrbaine2018, Ocsge,",
"Sybarval, Voirie2018, ZonesBaties2018, UsageSol, ) def get_label(code=\"\", label=\"\"): if code",
"= ( \"id\", \"surface\", \"usage_2015\", \"usage_2018\", \"couverture_2015\", \"couverture_2018\", ) geo_field",
"\"usage_2018\", \"couverture_2015\", \"couverture_2018\", ) geo_field = \"mpoly\" model = Artificialisee2015to2018",
"\"code\", \"label\", \"is_artificial\", ) model = CouvertureSol class UsageSolSerializer(serializers.ModelSerializer): class",
"import serializers from rest_framework import serializers as s from .models",
"model = Renaturee2018to2015 class SybarvalSerializer(serializers.GeoFeatureModelSerializer): class Meta: fields = (",
"return get_label(code=obj.cs_2015, label=obj.cs_2015_label) def get_couverture_2018(self, obj): return get_label(code=obj.cs_2018, label=obj.cs_2018_label) class",
"class CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer): \"\"\"Marker GeoJSON serializer.\"\"\" class Meta: \"\"\"Marker serializer meta",
"from rest_framework import serializers as s from .models import (",
"CouvertureSol, EnveloppeUrbaine2018, Ocsge, Renaturee2018to2015, Sybarval, Voirie2018, ZonesBaties2018, UsageSol, ) def",
"get_label(code=obj.us_2015, label=obj.us_2015_label) def get_usage_2018(self, obj): return get_label(code=obj.us_2018, label=obj.us_2018_label) def get_couverture_2015(self,",
"model = Voirie2018 class ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage =",
"if label is None: label = \"inconnu\" return f\"{code} {label[:30]}\"",
"= ( \"id\", \"parent\", \"code\", \"label\", ) model = UsageSol",
"return get_label(code=obj.us_2015, label=obj.us_2015_label) def get_usage_2018(self, obj): return get_label(code=obj.us_2018, label=obj.us_2018_label) def",
"( \"id\", \"couverture\", \"surface\", ) geo_field = \"mpoly\" model =",
"get_couverture_2015(self, obj): return get_label(code=obj.cs_2015, label=obj.cs_2015_label) def get_couverture_2018(self, obj): return get_label(code=obj.cs_2018,",
"= ( \"id\", \"couverture\", \"surface\", ) geo_field = \"mpoly\" model",
"= Ocsge class Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 = s.SerializerMethodField()",
"= s.SerializerMethodField() couverture_2018 = s.SerializerMethodField() def get_usage_2015(self, obj): return get_label(code=obj.us_2015,",
"get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) def get_usage(self, obj): return get_label(code=obj.usage,",
"= \"mpoly\" model = EnveloppeUrbaine2018 class OcsgeSerializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField()",
"\"mpoly\" model = Ocsge class Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018",
"def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) class Meta: fields =",
"get_label(code=obj.usage, label=obj.usage_label) class Meta: fields = ( \"id\", \"couverture\", \"usage\",",
"= Artificialisee2015to2018 class Artificielle2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self, obj):",
"( \"id\", \"surface\", \"couverture\", \"usage\", ) geo_field = \"mpoly\" model",
"class Meta: fields = ( \"id\", \"surface\", ) geo_field =",
") geo_field = \"mpoly\" model = Renaturee2018to2015 class SybarvalSerializer(serializers.GeoFeatureModelSerializer): class",
"= \"mpoly\" model = Sybarval class Voirie2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField()",
"get_label(code=obj.couverture, label=obj.couverture_label) class Meta: fields = ( \"id\", \"surface\", \"couverture\",",
"Artificialisee2015to2018 class Artificielle2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self, obj): return",
"class Artificielle2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture,",
"\"surface\", \"usage_2015\", \"usage_2018\", \"couverture_2015\", \"couverture_2018\", ) geo_field = \"mpoly\" model",
"get_label(code=\"\", label=\"\"): if code is None: code = \"-\" if",
"label = \"inconnu\" return f\"{code} {label[:30]}\" class Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer): usage_2015 =",
"\"millesime\", \"map_color\", \"year\", ) geo_field = \"mpoly\" model = Ocsge",
"obj): return get_label(code=obj.us_2015, label=obj.us_2015_label) def get_usage_2018(self, obj): return get_label(code=obj.us_2018, label=obj.us_2018_label)",
"model = EnveloppeUrbaine2018 class OcsgeSerializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage =",
"\"surface\", ) geo_field = \"mpoly\" model = Sybarval class Voirie2018Serializer(serializers.GeoFeatureModelSerializer):",
"get_label(code=obj.cs_2018, label=obj.cs_2018_label) class Meta: fields = ( \"id\", \"surface\", \"usage_2015\",",
"ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def get_couverture(self, obj):",
"\"parent\", \"code\", \"label\", \"is_artificial\", ) model = CouvertureSol class UsageSolSerializer(serializers.ModelSerializer):",
"Artificielle2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label)",
"= CommunesSybarval class EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self, obj):",
"serializer.\"\"\" class Meta: \"\"\"Marker serializer meta class.\"\"\" fields = (",
"\"mpoly\" model = Artificialisee2015to2018 class Artificielle2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def",
"= \"mpoly\" model = CommunesSybarval class EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField()",
"fields = ( \"id\", \"parent\", \"code\", \"label\", ) model =",
"serializer meta class.\"\"\" fields = ( \"nom\", \"code_insee\", \"surface\", )",
"\"-\" if label is None: label = \"inconnu\" return f\"{code}",
"f\"{code} {label[:30]}\" class Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 = s.SerializerMethodField()",
"\"id\", \"surface\", \"couverture\", ) geo_field = \"mpoly\" model = Artificielle2018",
"= \"mpoly\" model = Ocsge class Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField()",
"Sybarval class Voirie2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def",
"( \"id\", \"parent\", \"code\", \"label\", \"is_artificial\", ) model = CouvertureSol",
"class UsageSolSerializer(serializers.ModelSerializer): class Meta: fields = ( \"id\", \"parent\", \"code\",",
"label=obj.us_2018_label) def get_couverture_2015(self, obj): return get_label(code=obj.cs_2015, label=obj.cs_2015_label) def get_couverture_2018(self, obj):",
"\"\"\"Marker GeoJSON serializer.\"\"\" class Meta: \"\"\"Marker serializer meta class.\"\"\" fields",
"= \"mpoly\" model = Artificielle2018 class CommunesSybarvalSerializer(serializers.GeoFeatureModelSerializer): \"\"\"Marker GeoJSON serializer.\"\"\"",
"= ( \"id\", \"parent\", \"code\", \"label\", \"is_artificial\", ) model =",
"EnveloppeUrbaine2018, Ocsge, Renaturee2018to2015, Sybarval, Voirie2018, ZonesBaties2018, UsageSol, ) def get_label(code=\"\",",
"code = \"-\" if label is None: label = \"inconnu\"",
"usage_2015 = s.SerializerMethodField() usage_2018 = s.SerializerMethodField() couverture_2015 = s.SerializerMethodField() couverture_2018",
"= Renaturee2018to2015 class SybarvalSerializer(serializers.GeoFeatureModelSerializer): class Meta: fields = ( \"id\",",
"Renaturee2018to2015 class SybarvalSerializer(serializers.GeoFeatureModelSerializer): class Meta: fields = ( \"id\", \"surface\",",
"class Voirie2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def get_couverture(self,",
"\"id\", \"couverture\", \"usage\", \"surface\", ) geo_field = \"mpoly\" model =",
"\"surface\", \"couverture\", ) geo_field = \"mpoly\" model = Artificielle2018 class",
"\"couverture_2018\", ) geo_field = \"mpoly\" model = Artificialisee2015to2018 class Artificielle2018Serializer(serializers.GeoFeatureModelSerializer):",
"geo_field = \"mpoly\" model = Renaturee2018to2015 class SybarvalSerializer(serializers.GeoFeatureModelSerializer): class Meta:",
"UsageSol, ) def get_label(code=\"\", label=\"\"): if code is None: code",
"code is None: code = \"-\" if label is None:",
"{label[:30]}\" class Artificialisee2015to2018Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 = s.SerializerMethodField() couverture_2015",
"get_usage_2018(self, obj): return get_label(code=obj.us_2018, label=obj.us_2018_label) def get_couverture_2015(self, obj): return get_label(code=obj.cs_2015,",
"\"usage_2015\", \"usage_2018\", \"couverture_2015\", \"couverture_2018\", ) geo_field = \"mpoly\" model =",
"ZonesBaties2018, UsageSol, ) def get_label(code=\"\", label=\"\"): if code is None:",
"get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) class Meta: fields = (",
"= \"mpoly\" model = Renaturee2018to2015 class SybarvalSerializer(serializers.GeoFeatureModelSerializer): class Meta: fields",
"\"usage\", ) geo_field = \"mpoly\" model = Voirie2018 class ZonesBaties2018Serializer(serializers.GeoFeatureModelSerializer):",
"get_label(code=obj.us_2018, label=obj.us_2018_label) def get_couverture_2015(self, obj): return get_label(code=obj.cs_2015, label=obj.cs_2015_label) def get_couverture_2018(self,",
"\"mpoly\" model = EnveloppeUrbaine2018 class OcsgeSerializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage",
"= CouvertureSol class UsageSolSerializer(serializers.ModelSerializer): class Meta: fields = ( \"id\",",
"Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 = s.SerializerMethodField() couverture_2015 = s.SerializerMethodField()",
"ZonesBaties2018 class CouvertureSolSerializer(serializers.ModelSerializer): class Meta: fields = ( \"id\", \"parent\",",
"( \"id\", \"couverture\", \"usage\", \"surface\", ) geo_field = \"mpoly\" model",
") geo_field = \"mpoly\" model = Sybarval class Voirie2018Serializer(serializers.GeoFeatureModelSerializer): couverture",
"model = Ocsge class Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer): usage_2015 = s.SerializerMethodField() usage_2018 =",
"\"nom\", \"code_insee\", \"surface\", ) geo_field = \"mpoly\" model = CommunesSybarval",
"fields = ( \"id\", \"couverture\", \"surface\", ) geo_field = \"mpoly\"",
"class Meta: fields = ( \"id\", \"surface\", \"usage_2015\", \"usage_2018\", \"couverture_2015\",",
"as s from .models import ( Artificialisee2015to2018, Artificielle2018, CommunesSybarval, CouvertureSol,",
"\"\"\"Marker serializer meta class.\"\"\" fields = ( \"nom\", \"code_insee\", \"surface\",",
"class EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self, obj): return get_label(code=obj.couverture,",
"model = CommunesSybarval class EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self,",
"EnveloppeUrbaine2018 class OcsgeSerializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField() def",
") geo_field = \"mpoly\" model = Ocsge class Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer): usage_2015",
"fields = ( \"id\", \"couverture\", \"usage\", \"surface\", ) geo_field =",
"Meta: fields = ( \"id\", \"surface\", \"usage_2015\", \"usage_2018\", \"couverture_2015\", \"couverture_2018\",",
"model = Artificialisee2015to2018 class Artificielle2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self,",
"= Sybarval class Voirie2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() usage = s.SerializerMethodField()",
"geo_field = \"mpoly\" model = ZonesBaties2018 class CouvertureSolSerializer(serializers.ModelSerializer): class Meta:",
"obj): return get_label(code=obj.cs_2018, label=obj.cs_2018_label) class Meta: fields = ( \"id\",",
"s from .models import ( Artificialisee2015to2018, Artificielle2018, CommunesSybarval, CouvertureSol, EnveloppeUrbaine2018,",
"Renaturee2018to2015, Sybarval, Voirie2018, ZonesBaties2018, UsageSol, ) def get_label(code=\"\", label=\"\"): if",
"return get_label(code=obj.couverture, label=obj.couverture_label) class Meta: fields = ( \"id\", \"surface\",",
"import ( Artificialisee2015to2018, Artificielle2018, CommunesSybarval, CouvertureSol, EnveloppeUrbaine2018, Ocsge, Renaturee2018to2015, Sybarval,",
"get_usage_2015(self, obj): return get_label(code=obj.us_2015, label=obj.us_2015_label) def get_usage_2018(self, obj): return get_label(code=obj.us_2018,",
"def get_couverture_2015(self, obj): return get_label(code=obj.cs_2015, label=obj.cs_2015_label) def get_couverture_2018(self, obj): return",
"class Meta: fields = ( \"id\", \"surface\", \"couverture\", ) geo_field",
"= ( \"id\", \"surface\", \"couverture\", ) geo_field = \"mpoly\" model",
"class.\"\"\" fields = ( \"nom\", \"code_insee\", \"surface\", ) geo_field =",
"def get_couverture(self, obj): return get_label(code=obj.couverture, label=obj.couverture_label) def get_usage(self, obj): return",
"\"year\", ) geo_field = \"mpoly\" model = Ocsge class Renaturee2018to2015Serializer(serializers.GeoFeatureModelSerializer):",
"\"couverture\", \"usage\", \"surface\", ) geo_field = \"mpoly\" model = ZonesBaties2018",
"s.SerializerMethodField() def get_usage_2015(self, obj): return get_label(code=obj.us_2015, label=obj.us_2015_label) def get_usage_2018(self, obj):",
"label is None: label = \"inconnu\" return f\"{code} {label[:30]}\" class",
"\"map_color\", \"year\", ) geo_field = \"mpoly\" model = Ocsge class",
"s.SerializerMethodField() couverture_2015 = s.SerializerMethodField() couverture_2018 = s.SerializerMethodField() def get_usage_2015(self, obj):",
"= \"mpoly\" model = ZonesBaties2018 class CouvertureSolSerializer(serializers.ModelSerializer): class Meta: fields",
"\"code_insee\", \"surface\", ) geo_field = \"mpoly\" model = CommunesSybarval class",
"Meta: fields = ( \"id\", \"parent\", \"code\", \"label\", ) model",
"Meta: fields = ( \"id\", \"couverture\", \"surface\", ) geo_field =",
"CommunesSybarval class EnveloppeUrbaine2018Serializer(serializers.GeoFeatureModelSerializer): couverture = s.SerializerMethodField() def get_couverture(self, obj): return"
] |
[
"from django.contrib import admin from .models import SearchResult # Register",
"your models here. class SearchResultAdmin(admin.ModelAdmin): fields = [\"query\", \"heading\", \"url\",",
"import admin from .models import SearchResult # Register your models",
"import SearchResult # Register your models here. class SearchResultAdmin(admin.ModelAdmin): fields",
"# Register your models here. class SearchResultAdmin(admin.ModelAdmin): fields = [\"query\",",
"django.contrib import admin from .models import SearchResult # Register your",
"Register your models here. class SearchResultAdmin(admin.ModelAdmin): fields = [\"query\", \"heading\",",
"here. class SearchResultAdmin(admin.ModelAdmin): fields = [\"query\", \"heading\", \"url\", \"text\"] admin.site.register(SearchResult,",
"class SearchResultAdmin(admin.ModelAdmin): fields = [\"query\", \"heading\", \"url\", \"text\"] admin.site.register(SearchResult, SearchResultAdmin)",
".models import SearchResult # Register your models here. class SearchResultAdmin(admin.ModelAdmin):",
"SearchResult # Register your models here. class SearchResultAdmin(admin.ModelAdmin): fields =",
"models here. class SearchResultAdmin(admin.ModelAdmin): fields = [\"query\", \"heading\", \"url\", \"text\"]",
"from .models import SearchResult # Register your models here. class",
"admin from .models import SearchResult # Register your models here."
] |
[
"nlu_data = await asyncio.gather( file_importer.get_stories(), file_importer.get_nlu_data() ) # if stories.is_empty()",
"output_path: Text = DEFAULT_MODELS_PATH, force_training: bool = False, fixed_model_name: Optional[Text]",
"train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod from rasa_addons.importers import BotfrontFileImporter",
"was found. Only an nlu-model was created.\" \"Please specify a",
"= await file_importer.get_domain() # if domain.is_empty(): # return await handle_domain_if_not_exists(",
"rasa.importers.importer import TrainingDataImporter from rasa import model from rasa.model import",
"persist_nlu_training_data: bool = False, additional_arguments: Optional[Dict] = None, ): if",
"training data given. Please provide stories and NLU data in",
"# training NLU only hence the training files still have",
"to retrain Core model.\", color=bcolors.OKBLUE, ) if fingerprint_comparison_result.should_retrain_nlu(): await _train_nlu_with_validated_data(",
"[l for l, d in nlu_data.items() if d.is_empty()] fingerprint_comparison.core =",
"config: Text, stories: Text, output: Text, train_path: Optional[Text] = None,",
"if domain.is_empty(): print_error( \"Core training was skipped because no valid",
"None, ) -> Optional[Text]: \"\"\"Train Core with validated training and",
"Core model will be trained.\") # return await _train_core_with_validated_data( #",
"Rasa Core model will be trained.\") # return await _train_core_with_validated_data(",
"Core with validated training and config data.\"\"\" import rasa.core.train with",
"List[Text]] = True ) -> Optional[Text]: \"\"\"Train NLU with validated",
"persist_nlu_training_data=persist_nlu_training_data, ) async def _train_nlu_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path:",
"\" \"the updated templates will be created.\", color=bcolors.OKBLUE, ) await",
"argument or check if the provided domain file exists.\" )",
"import asyncio import os import tempfile from contextlib import ExitStack",
"tempfile from contextlib import ExitStack from typing import Text, Optional,",
"Please provide NLU data in order to train \" \"a",
"file_importer = BotfrontFileImporter(config, domain, training_files) # domain = await file_importer.get_domain()",
"the config file for Core. stories: Path to the Core",
"fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False, additional_arguments: Optional[Dict]",
"\"\".format(os.path.abspath(old_model)) ) return old_model async def _do_training( file_importer: TrainingDataImporter, output_path:",
"data has not changed. fixed_model_name: Name of model to be",
"of all langs fingerprint_comparison.nlu = list(new_fingerprint.get(\"nlu-config\", {}).keys()) domain = await",
"output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) async def _train_core_with_validated_data( file_importer: TrainingDataImporter,",
"def _train_nlu_async( config: Text, nlu_data: Text, output: Text, train_path: Optional[Text]",
"If `True` retrain model even if data has not changed.",
"exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod config = await",
"_train_core_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) async def _train_core_with_validated_data(",
"the model will be trained in a temporary directory, otherwise",
"will be trained.\") # return await _train_core_with_validated_data( # file_importer, #",
"trained model files. \"\"\" loop = asyncio.get_event_loop() return loop.run_until_complete( _train_nlu_async(",
"fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) ) async def train_core_async( domain: Union[Domain, Text],",
"bool = False, ): if not nlu_data: print_error( \"No NLU",
"NLU. output_path: Output path. force_training: If `True` retrain model even",
"for l, d in nlu_data.items() if d.is_empty()] fingerprint_comparison.core = fingerprint_comparison.core",
"domain, training_files # ) with ExitStack() as stack: train_path =",
"supplies the training data. train_path: Directory in which to train",
"model will not be compressed. additional_arguments: Additional training parameters. Returns:",
"still have to be selected file_importer = TrainingDataImporter.load_nlu_importer_from_config( config, training_data_paths=[nlu_data]",
"_train_nlu_with_validated_data( file_importer, output=output_path, fixed_model_name=fixed_model_name ) print_warning( \"Core training was skipped",
"= FingerprintComparisonResult() if fingerprint_comparison_result.should_retrain_core(): await _train_core_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name,",
"created.\", color=bcolors.OKBLUE, ) await model.update_model_with_new_domain(file_importer, train_path) else: print_color( \"Core stories/configuration",
"# ) new_fingerprint = await model.model_fingerprint(file_importer) old_model = model.get_latest_model(output_path) fingerprint_comparison",
"training data. output: Output path. train_path: If `None` the model",
"# </ bf mod if fingerprint_comparison.is_training_required(): await _do_training( file_importer, output_path=output_path,",
"train_path is None: # Only Core was trained. new_fingerprint =",
"Otherwise, create a temp train path and clean it up",
"model archive, otherwise the path to the directory with the",
"validated training and config data.\"\"\" import rasa.nlu.train with ExitStack() as",
"format. \" \"The NLU model training will be skipped now.\"",
"TrainingDataImporter from rasa import model from rasa.model import FingerprintComparisonResult from",
"old_model async def _do_training( file_importer: TrainingDataImporter, output_path: Text, train_path: Text,",
"`True` if the NLU training data should be persisted with",
"additional_arguments: Optional[Dict], ) -> Optional[Text]: \"\"\"Trains a Rasa model (Core",
"= None, ): if not fingerprint_comparison_result: fingerprint_comparison_result = FingerprintComparisonResult() if",
"_train_nlu_async( config: Text, nlu_data: Text, output: Text, train_path: Optional[Text] =",
"argument.\" ) return # training NLU only hence the training",
"data has not changed. persist_nlu_training_data: `True` if the NLU training",
"model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"core-\", ) return",
"files. \"\"\" loop = asyncio.get_event_loop() return loop.run_until_complete( _train_nlu_async( config, nlu_data,",
"data format. \" \"The NLU model training will be skipped",
"with the model. additional_arguments: Additional training parameters. Returns: Path of",
"loop = asyncio.get_event_loop() except RuntimeError: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) return",
"is None: # Only Core was trained. new_fingerprint = await",
"models[lang], _ = await rasa.nlu.train( config[lang], file_importer, _train_path, fixed_model_name=\"nlu-{}\".format(lang), persist_nlu_training_data=persist_nlu_training_data,",
"to the domain file. config: Path to the config file",
"stories given. Please provide stories in order to \" \"train",
"False, additional_arguments: Optional[Dict] = None, ): if not fingerprint_comparison_result: fingerprint_comparison_result",
"domain file exists.\" ) return None if not await file_importer.get_stories():",
"Use only from `train_async`. Args: file_importer: `TrainingDataImporter` which supplies the",
"persist_nlu_training_data, additional_arguments, ) async def handle_domain_if_not_exists( file_importer: TrainingDataImporter, output_path, fixed_model_name",
"NLU model.\", color=bcolors.OKBLUE, ) def train_core( domain: Union[Domain, Text], config:",
"asyncio.gather( file_importer.get_domain(), file_importer.get_config() ) await rasa.core.train( domain_file=domain, training_resource=file_importer, output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME),",
"only from `train_async`. Args: file_importer: `TrainingDataImporter` which supplies the training",
") def train_core( domain: Union[Domain, Text], config: Text, stories: Text,",
"True ) -> Optional[Text]: \"\"\"Train NLU with validated training and",
"domain.is_empty(): # return await handle_domain_if_not_exists( # file_importer, output_path, fixed_model_name #",
"training_files=training_files, output_path=output, force_training=force_training, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) ) async def",
"color=bcolors.OKBLUE) # /bf mod print_color(\"NLU model training completed.\", color=bcolors.OKBLUE) if",
"TrainingDataImporter.load_nlu_importer_from_config( config, training_data_paths=[nlu_data] ) training_datas = await file_importer.get_nlu_data() if training_datas.is_empty():",
"completed.\", color=bcolors.OKBLUE) if train_path is None: # Only NLU was",
"\"train a Rasa Core model using the '--stories' argument.\" )",
"the provided domain file exists.\" ) return nlu_model_only async def",
"output: Text, train_path: Optional[Text] = None, fixed_model_name: Optional[Text] = None,",
"Path to the config file for NLU. nlu_data: Path to",
") domain = await file_importer.get_domain() if domain.is_empty(): print_error( \"Core training",
"_train_path = train_path else: # Otherwise, create a temp train",
"config[lang], file_importer, _train_path, fixed_model_name=\"nlu-{}\".format(lang), persist_nlu_training_data=persist_nlu_training_data, ) else: print_color(\"NLU data for",
"Optional[Dict] = None, ) -> Optional[Text]: loop = asyncio.get_event_loop() return",
"bcolors, print_color, ) from rasa.constants import DEFAULT_MODELS_PATH, DEFAULT_CORE_SUBDIRECTORY_NAME def train(",
"changed. A new model with \" \"the updated templates will",
"No need to retrain NLU model.\", color=bcolors.OKBLUE, ) def train_core(",
"file_importer.get_nlu_data() if training_datas.is_empty(): print_error( f\"Path '{nlu_data}' doesn't contain valid NLU",
"trained.\") # return await _train_core_with_validated_data( # file_importer, # output=output_path, #",
"fixed_model_name # ) # /bf mod return await _train_async_internal( file_importer,",
"= asyncio.get_event_loop() except RuntimeError: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) return loop.run_until_complete(",
"Optional[Text] = None, persist_nlu_training_data: bool = False, ): if not",
"from rasa.importers.importer import TrainingDataImporter from rasa import model from rasa.model",
"# normal (not compare) training print_color(\"Training Core model...\", color=bcolors.OKBLUE) domain,",
"rasa.cli.utils import ( print_success, print_warning, print_error, bcolors, print_color, ) from",
"train_path=train_path, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, ) async def _train_nlu_with_validated_data( file_importer: TrainingDataImporter, output:",
"output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"core-\", ) return _train_path def train_nlu( config:",
"skipping training...\".format(lang), color=bcolors.OKBLUE) # /bf mod print_color(\"NLU model training completed.\",",
"file_importer.get_stories(): print_error( \"No stories given. Please provide stories in order",
"train_path=train_path, fixed_model_name=fixed_model_name, ) print_success( \"Nothing changed. You can use the",
"directory, otherwise in the provided directory. fixed_model_name: Name of the",
"print_color(\"Core model training completed.\", color=bcolors.OKBLUE) if train_path is None: #",
"/bf mod print_color(\"NLU model training completed.\", color=bcolors.OKBLUE) if train_path is",
"to the domain file. config: Dict of paths to the",
"{}).keys()) domain = await file_importer.get_domain() core_untrainable = domain.is_empty() or stories.is_empty()",
"if train_path is None: # Only NLU was trained new_fingerprint",
"the provided directory. fixed_model_name: Name of the model to be",
"the model. Returns: If `train_path` is given it returns the",
"train_path: Text, output_path: Text, force_training: bool, fixed_model_name: Optional[Text], persist_nlu_training_data: bool,",
"from typing import Text, Optional, List, Union, Dict from rasa.importers.importer",
"data/configuration did not change. No need to retrain NLU model.\",",
"new model with \" \"the updated templates will be created.\",",
"= await rasa.nlu.train( config[lang], file_importer, _train_path, fixed_model_name=\"nlu-{}\".format(lang), persist_nlu_training_data=persist_nlu_training_data, ) else:",
"selected file_importer = TrainingDataImporter.load_nlu_importer_from_config( config, training_data_paths=[nlu_data] ) training_datas = await",
"the trained model files. \"\"\" loop = asyncio.get_event_loop() return loop.run_until_complete(",
") async def _train_nlu_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path: Optional[Text]",
"training since domain or stories are empty.\", color=bcolors.OKBLUE) for lang",
"on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # normal (not compare) training",
"stories: Path to the Core training data. output: Output path.",
"import DEFAULT_MODELS_PATH, DEFAULT_CORE_SUBDIRECTORY_NAME def train( domain: Text, config: Text, training_files:",
"Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Trains a Core model.",
"domain_file=domain, training_resource=file_importer, output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME), policy_config=config, additional_arguments=additional_arguments, ) print_color(\"Core model training",
"model training completed.\", color=bcolors.OKBLUE) if train_path is None: # Only",
"train_path: Optional[Text] = None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool",
"is None: try: loop = asyncio.get_event_loop() except RuntimeError: loop =",
"it up on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod",
"file exists.\" ) return None if not await file_importer.get_stories(): print_error(",
"nlu_untrainable = [l for l, d in nlu_data.items() if d.is_empty()]",
"None, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Train Core",
"= False, ) -> Optional[Text]: \"\"\"Trains an NLU model. Args:",
"Core training data. output: Output path. train_path: If `None` the",
"nlu_data.is_empty(): # print_warning(\"No NLU data present. Just a Rasa Core",
"async def handle_domain_if_not_exists( file_importer: TrainingDataImporter, output_path, fixed_model_name ): nlu_model_only =",
"None if not await file_importer.get_stories(): print_error( \"No stories given. Please",
"stored. persist_nlu_training_data: `True` if the NLU training data should be",
"> if fingerprint_comparison.nlu == True: # replace True with list",
"if fingerprint_comparison_result.should_retrain_core(): await _train_core_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, )",
"compressed. additional_arguments: Additional training parameters. Returns: If `train_path` is given",
"import model from rasa.model import FingerprintComparisonResult from rasa.core.domain import Domain",
"None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False, additional_arguments:",
"file_importer: TrainingDataImporter, output_path, fixed_model_name ): nlu_model_only = await _train_nlu_with_validated_data( file_importer,",
"Optional[Text]: loop = asyncio.get_event_loop() return loop.run_until_complete( train_core_async( domain=domain, config=config, stories=stories,",
"rasa.utils.common import TempDirectoryPath from rasa.cli.utils import ( print_success, print_warning, print_error,",
"no valid domain file was found. \" \"Please specify a",
"You can use the old model stored at '{}'.\" \"\".format(os.path.abspath(old_model))",
"langs fingerprint_comparison.nlu = list(new_fingerprint.get(\"nlu-config\", {}).keys()) domain = await file_importer.get_domain() core_untrainable",
"return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"nlu-\", ) return _train_path",
"will be created.\", color=bcolors.OKBLUE, ) await model.update_model_with_new_domain(file_importer, train_path) else: print_color(",
"templates section has been changed. A new model with \"",
"skipping training...\".format(lang), color=bcolors.OKBLUE) # </ bf mod if fingerprint_comparison.is_training_required(): await",
"be created.\", color=bcolors.OKBLUE, ) await model.update_model_with_new_domain(file_importer, train_path) else: print_color( \"Core",
"fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, ) async def _train_nlu_with_validated_data( file_importer: TrainingDataImporter, output: Text,",
"print_error( # \"No training data given. Please provide stories and",
"[l for l in fingerprint_comparison.nlu if l not in nlu_untrainable]",
") -> Optional[Text]: \"\"\"Train Core with validated training and config",
"fingerprint_comparison_result=fingerprint_comparison, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) return model.package_model( fingerprint=new_fingerprint, output_directory=output_path, train_path=train_path,",
"an NLU model. Args: config: Path to the config file",
"from rasa import model from rasa.model import FingerprintComparisonResult from rasa.core.domain",
"fingerprint_comparison_result.should_retrain_nlg(): print_color( \"Core stories/configuration did not change. \" \"Only the",
"persist_nlu_training_data=persist_nlu_training_data, ) else: print_color(\"NLU data for language <{}> didn't change,",
"model archive. \"\"\" # file_importer = TrainingDataImporter.load_from_config( # config, domain,",
"# If the train path was provided, do nothing on",
"old_model, train_path ) # bf mod > if fingerprint_comparison.nlu ==",
"= None, ) -> Optional[Text]: loop = asyncio.get_event_loop() return loop.run_until_complete(",
"output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) ) async def train_core_async( domain:",
"and config data.\"\"\" import rasa.nlu.train with ExitStack() as stack: models",
"it returns the path to the model archive, otherwise the",
"Text, config: Text, training_files: Union[Text, List[Text]], output: Text = DEFAULT_MODELS_PATH,",
"temp train path and clean it up on exit. _train_path",
"NLU training data. output: Output path. train_path: If `None` the",
"for Core and NLU. Keys are language codes training_files: Paths",
"\" \"Only the templates section has been changed. A new",
"typing import Text, Optional, List, Union, Dict from rasa.importers.importer import",
"await _train_core_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) elif fingerprint_comparison_result.should_retrain_nlg():",
"updated templates will be created.\", color=bcolors.OKBLUE, ) await model.update_model_with_new_domain(file_importer, train_path)",
"Core. stories: Path to the Core training data. output: Output",
"will not be compressed. additional_arguments: Additional training parameters. Returns: If",
"output_path, fixed_model_name # ) # /bf mod return await _train_async_internal(",
"to the directory with the trained model files. \"\"\" file_importer",
"provided domain file exists.\" ) return None if not await",
"as stack: train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod from rasa_addons.importers",
"DEFAULT_MODELS_PATH, force_training: bool = False, fixed_model_name: Optional[Text] = None, persist_nlu_training_data:",
"Text, nlu_data: Text, output: Text, train_path: Optional[Text] = None, fixed_model_name:",
"model.should_retrain( new_fingerprint, old_model, train_path ) # bf mod > if",
"= {} from rasa.nlu import config as cfg_loader if train_path:",
"train_path: Text, fingerprint_comparison_result: Optional[FingerprintComparisonResult] = None, fixed_model_name: Optional[Text] = None,",
"\"\"\" file_importer = TrainingDataImporter.load_core_importer_from_config( config, domain, [stories] ) domain =",
"`True` retrain model even if data has not changed. fixed_model_name:",
"additional_arguments=additional_arguments, ) elif fingerprint_comparison_result.should_retrain_nlg(): print_color( \"Core stories/configuration did not change.",
"import FingerprintComparisonResult from rasa.core.domain import Domain from rasa.utils.common import TempDirectoryPath",
"Just a Rasa Core model will be trained.\") # return",
"= None, ) -> Optional[Text]: \"\"\"Trains a Core model. Args:",
"= TrainingDataImporter.load_nlu_importer_from_config( config, training_data_paths=[nlu_data] ) training_datas = await file_importer.get_nlu_data() if",
"language <{}> didn't change, skipping training...\".format(lang), color=bcolors.OKBLUE) # /bf mod",
"import rasa.nlu.train with ExitStack() as stack: models = {} from",
"print_success( \"Nothing changed. You can use the old model stored",
"on exit. _train_path = train_path else: # Otherwise, create a",
"Union, Dict from rasa.importers.importer import TrainingDataImporter from rasa import model",
"in order to train \" \"a Rasa NLU model using",
"the '--nlu' argument.\" ) return # training NLU only hence",
"fixed_model_name: Name of the model to be stored. persist_nlu_training_data: `True`",
"model will be trained in a temporary directory, otherwise in",
"stories in order to \" \"train a Rasa Core model",
"should be persisted with the model. fixed_model_name: Name of model",
"domain.is_empty(): print_error( \"Core training was skipped because no valid domain",
"for language <{}> didn't change, skipping training...\".format(lang), color=bcolors.OKBLUE) # /bf",
"# /bf mod return await _train_async_internal( file_importer, train_path, output_path, force_training,",
"False, ) -> Optional[Text]: \"\"\"Trains an NLU model. Args: config:",
"await file_importer.get_domain() core_untrainable = domain.is_empty() or stories.is_empty() nlu_untrainable = [l",
"A new model with \" \"the updated templates will be",
"NLU training data should be persisted with the model. fixed_model_name:",
"with ExitStack() as stack: if train_path: # If the train",
"lang in nlu_untrainable: print_color(\"No NLU data found for language <{}>,",
"output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, retrain_nlu=fingerprint_comparison_result.nlu, persist_nlu_training_data=persist_nlu_training_data, ) else: print_color( \"NLU data/configuration",
"train_path: If `None` the model will be trained in a",
"None, persist_nlu_training_data: bool = False, ) -> Optional[Text]: \"\"\"Trains an",
"None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False, ):",
"train a Rasa model using the '--data' argument.\" # )",
"# print_warning(\"No NLU data present. Just a Rasa Core model",
") return nlu_model_only async def _train_async_internal( file_importer: TrainingDataImporter, train_path: Text,",
"provided domain file exists.\" ) return nlu_model_only async def _train_async_internal(",
"= await file_importer.get_domain() if domain.is_empty(): print_error( \"Core training was skipped",
"if not fingerprint_comparison_result: fingerprint_comparison_result = FingerprintComparisonResult() if fingerprint_comparison_result.should_retrain_core(): await _train_core_with_validated_data(",
"await model.update_model_with_new_domain(file_importer, train_path) else: print_color( \"Core stories/configuration did not change.",
") else: print_color( \"NLU data/configuration did not change. No need",
"# replace True with list of all langs fingerprint_comparison.nlu =",
"do nothing on exit. _train_path = train_path else: # Otherwise,",
"if stories.is_empty() and nlu_data.is_empty(): # print_error( # \"No training data",
"of model to be stored. additional_arguments: Additional training parameters. Returns:",
"nothing on exit. _train_path = train_path else: # Otherwise, create",
"compare) training print_color(\"Training Core model...\", color=bcolors.OKBLUE) domain, config = await",
"None: # Only Core was trained. new_fingerprint = await model.model_fingerprint(file_importer)",
"fixed_model_name, persist_nlu_training_data, additional_arguments, ) async def handle_domain_if_not_exists( file_importer: TrainingDataImporter, output_path,",
"Path to the NLU training data. output: Output path. train_path:",
"l, d in nlu_data.items() if d.is_empty()] fingerprint_comparison.core = fingerprint_comparison.core and",
"now.\" ) return return await _train_nlu_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name,",
"import BotfrontFileImporter file_importer = BotfrontFileImporter(config, domain, training_files) # domain =",
"l in fingerprint_comparison.nlu if l not in nlu_untrainable] if core_untrainable:",
"import Domain from rasa.utils.common import TempDirectoryPath from rasa.cli.utils import (",
"file_importer.get_domain() core_untrainable = domain.is_empty() or stories.is_empty() nlu_untrainable = [l for",
"# Only Core was trained. new_fingerprint = await model.model_fingerprint(file_importer) return",
"directory, otherwise in the provided directory. fixed_model_name: Name of model",
"skipped because no valid domain file was found. \" \"Please",
"the provided domain file exists.\" ) return None if not",
"didn't change, skipping training...\".format(lang), color=bcolors.OKBLUE) # /bf mod print_color(\"NLU model",
"handle_domain_if_not_exists( file_importer: TrainingDataImporter, output_path, fixed_model_name ): nlu_model_only = await _train_nlu_with_validated_data(",
"train_path=train_path, fixed_model_name=fixed_model_name, retrain_nlu=fingerprint_comparison_result.nlu, persist_nlu_training_data=persist_nlu_training_data, ) else: print_color( \"NLU data/configuration did",
") else: print_color(\"NLU data for language <{}> didn't change, skipping",
"Paths to the training data for Core and NLU. output_path:",
"( print_success, print_warning, print_error, bcolors, print_color, ) from rasa.constants import",
"<{}>, skipping training...\".format(lang), color=bcolors.OKBLUE) # </ bf mod if fingerprint_comparison.is_training_required():",
"True: # replace True with list of all langs fingerprint_comparison.nlu",
"model.get_latest_model(output_path) fingerprint_comparison = FingerprintComparisonResult(force_training=force_training) if not force_training: fingerprint_comparison = model.should_retrain(",
"_train_nlu_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, ) async def _train_nlu_with_validated_data(",
"stories and NLU data in \" # \"order to train",
"RuntimeError: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) return loop.run_until_complete( train_async( domain=domain, config=config,",
"be stored. persist_nlu_training_data: `True` if the NLU training data should",
") -> Optional[Text]: \"\"\"Trains a Core model. Args: domain: Path",
") training_datas = await file_importer.get_nlu_data() if training_datas.is_empty(): print_error( f\"Path '{nlu_data}'",
"rasa.core.train with ExitStack() as stack: if train_path: # If the",
"train_path: # If the train path was provided, do nothing",
"of model to be stored. persist_nlu_training_data: `True` if the NLU",
"TrainingDataImporter, output_path, fixed_model_name ): nlu_model_only = await _train_nlu_with_validated_data( file_importer, output=output_path,",
"for lang in config: if config[lang]: print_color(\"Start training {} NLU",
"using the '--stories' argument.\" ) return return await _train_core_with_validated_data( file_importer,",
"been changed. A new model with \" \"the updated templates",
"create a temp train path and clean it up on",
"train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"core-\", ) return _train_path def train_nlu( config: Text,",
"ExitStack from typing import Text, Optional, List, Union, Dict from",
"train_core( domain: Union[Domain, Text], config: Text, stories: Text, output: Text,",
"config, training_data_paths=[nlu_data] ) training_datas = await file_importer.get_nlu_data() if training_datas.is_empty(): print_error(",
"model ...\".format(lang), color=bcolors.OKBLUE) _, models[lang], _ = await rasa.nlu.train( config[lang],",
"nlu_model_only = await _train_nlu_with_validated_data( file_importer, output=output_path, fixed_model_name=fixed_model_name ) print_warning( \"Core",
"Core model...\", color=bcolors.OKBLUE) domain, config = await asyncio.gather( file_importer.get_domain(), file_importer.get_config()",
"Domain from rasa.utils.common import TempDirectoryPath from rasa.cli.utils import ( print_success,",
"clean it up on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # normal",
"with the trained model files. \"\"\" loop = asyncio.get_event_loop() return",
"to train a Rasa model using the '--data' argument.\" #",
"= list(new_fingerprint.get(\"nlu-config\", {}).keys()) domain = await file_importer.get_domain() core_untrainable = domain.is_empty()",
"# bf mod from rasa_addons.importers import BotfrontFileImporter file_importer = BotfrontFileImporter(config,",
"Name of model to be stored. uncompress: If `True` the",
"= asyncio.get_event_loop() return loop.run_until_complete( _train_nlu_async( config, nlu_data, output, train_path, fixed_model_name,",
"from rasa.cli.utils import ( print_success, print_warning, print_error, bcolors, print_color, )",
"= None, persist_nlu_training_data: bool = False, additional_arguments: Optional[Dict] = None,",
"Text, force_training: bool, fixed_model_name: Optional[Text], persist_nlu_training_data: bool, additional_arguments: Optional[Dict], )",
"are empty.\", color=bcolors.OKBLUE) for lang in nlu_untrainable: print_color(\"No NLU data",
"= True ) -> Optional[Text]: \"\"\"Train NLU with validated training",
"nlu_data, output, train_path, fixed_model_name, persist_nlu_training_data, ) ) async def _train_nlu_async(",
"Optional[asyncio.AbstractEventLoop] = None, ) -> Optional[Text]: if loop is None:",
"output, train_path, fixed_model_name, persist_nlu_training_data, ) ) async def _train_nlu_async( config:",
"Output path. force_training: If `True` retrain model even if data",
"found. Only an nlu-model was created.\" \"Please specify a valid",
"model.update_model_with_new_domain(file_importer, train_path) else: print_color( \"Core stories/configuration did not change. No",
"import TrainingDataImporter from rasa import model from rasa.model import FingerprintComparisonResult",
"asyncio import os import tempfile from contextlib import ExitStack from",
"given. Please provide stories in order to \" \"train a",
"force_training: bool, fixed_model_name: Optional[Text], persist_nlu_training_data: bool, additional_arguments: Optional[Dict], ) ->",
"persisted with the model. Returns: If `train_path` is given it",
"stories.is_empty() nlu_untrainable = [l for l, d in nlu_data.items() if",
"stack: if train_path: # If the train path was provided,",
"domain: Text, config: Text, training_files: Union[Text, List[Text]], output: Text =",
"from rasa.model import FingerprintComparisonResult from rasa.core.domain import Domain from rasa.utils.common",
"Optional[Dict], ) -> Optional[Text]: \"\"\"Trains a Rasa model (Core and",
"directory with the trained model files. \"\"\" loop = asyncio.get_event_loop()",
"fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False, retrain_nlu: Union[bool,",
"return return await _train_core_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, )",
"lang in config: if config[lang]: print_color(\"Start training {} NLU model",
"model using the '--data' argument.\" # ) # return #",
"= False, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False,",
"force_training: fingerprint_comparison = model.should_retrain( new_fingerprint, old_model, train_path ) # bf",
"loop = asyncio.get_event_loop() return loop.run_until_complete( _train_nlu_async( config, nlu_data, output, train_path,",
"not fingerprint_comparison_result: fingerprint_comparison_result = FingerprintComparisonResult() if fingerprint_comparison_result.should_retrain_core(): await _train_core_with_validated_data( file_importer,",
"to \" \"train a Rasa Core model using the '--stories'",
"# if nlu_data.is_empty(): # print_warning(\"No NLU data present. Just a",
"nlu_data.is_empty(): # print_error( # \"No training data given. Please provide",
"if l not in nlu_untrainable] if core_untrainable: print_color(\"Skipping Core training",
"Path to the config file for Core. stories: Path to",
"if core_untrainable: print_color(\"Skipping Core training since domain or stories are",
"Returns: Path of the trained model archive. \"\"\" # file_importer",
"rasa_addons.importers import BotfrontFileImporter file_importer = BotfrontFileImporter(config, domain, training_files) # domain",
"and not core_untrainable fingerprint_comparison.nlu = [l for l in fingerprint_comparison.nlu",
"normal (not compare) training print_color(\"Training Core model...\", color=bcolors.OKBLUE) domain, config",
"await _train_core_with_validated_data( # file_importer, # output=output_path, # fixed_model_name=fixed_model_name, # additional_arguments=additional_arguments,",
"additional_arguments=additional_arguments, ) return model.package_model( fingerprint=new_fingerprint, output_directory=output_path, train_path=train_path, fixed_model_name=fixed_model_name, ) print_success(",
"return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"core-\", ) return _train_path",
"templates will be created.\", color=bcolors.OKBLUE, ) await model.update_model_with_new_domain(file_importer, train_path) else:",
"to retrain NLU model.\", color=bcolors.OKBLUE, ) def train_core( domain: Union[Domain,",
"async def _train_core_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path: Optional[Text] =",
"with the model. fixed_model_name: Name of model to be stored.",
"Additional training parameters. Returns: Path of the trained model archive.",
"additional_arguments, ) async def handle_domain_if_not_exists( file_importer: TrainingDataImporter, output_path, fixed_model_name ):",
"config = await asyncio.gather( file_importer.get_domain(), file_importer.get_config() ) await rasa.core.train( domain_file=domain,",
"print_color, ) from rasa.constants import DEFAULT_MODELS_PATH, DEFAULT_CORE_SUBDIRECTORY_NAME def train( domain:",
"-> Optional[Text]: \"\"\"Trains a Core model. Args: domain: Path to",
"file. config: Path to the config file for Core. stories:",
"# domain = await file_importer.get_domain() # if domain.is_empty(): # return",
"= stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod from rasa_addons.importers import BotfrontFileImporter file_importer",
"def train_nlu( config: Text, nlu_data: Text, output: Text, train_path: Optional[Text]",
"created.\" \"Please specify a valid domain using '--domain' argument or",
"fingerprint_comparison.nlu if l not in nlu_untrainable] if core_untrainable: print_color(\"Skipping Core",
"loop.run_until_complete( _train_nlu_async( config, nlu_data, output, train_path, fixed_model_name, persist_nlu_training_data, ) )",
"Only NLU was trained new_fingerprint = await model.model_fingerprint(file_importer) return model.package_model(",
"if data has not changed. fixed_model_name: Name of model to",
"\"Please verify the data format. \" \"The NLU model training",
"= await file_importer.get_nlu_config(retrain_nlu) for lang in config: if config[lang]: print_color(\"Start",
"# if stories.is_empty() and nlu_data.is_empty(): # print_error( # \"No training",
"ExitStack() as stack: models = {} from rasa.nlu import config",
"_train_nlu_async( config, nlu_data, output, train_path, fixed_model_name, persist_nlu_training_data, ) ) async",
"train path and clean it up on exit. _train_path =",
"fingerprint_comparison.is_training_required(): await _do_training( file_importer, output_path=output_path, train_path=train_path, fingerprint_comparison_result=fingerprint_comparison, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments,",
"in it. \" \"Please verify the data format. \" \"The",
"None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False, retrain_nlu:",
"): nlu_model_only = await _train_nlu_with_validated_data( file_importer, output=output_path, fixed_model_name=fixed_model_name ) print_warning(",
"the Core training data. output: Output path. train_path: If `None`",
"path was provided, do nothing on exit. _train_path = train_path",
"cfg_loader if train_path: # If the train path was provided,",
"additional_arguments=additional_arguments, ) ) async def train_core_async( domain: Union[Domain, Text], config:",
"model...\", color=bcolors.OKBLUE) domain, config = await asyncio.gather( file_importer.get_domain(), file_importer.get_config() )",
"fingerprint_comparison.nlu = [l for l in fingerprint_comparison.nlu if l not",
"= await _train_nlu_with_validated_data( file_importer, output=output_path, fixed_model_name=fixed_model_name ) print_warning( \"Core training",
"given. Please provide stories and NLU data in \" #",
"# Only NLU was trained new_fingerprint = await model.model_fingerprint(file_importer) return",
"from rasa.nlu import config as cfg_loader if train_path: # If",
"# return # if nlu_data.is_empty(): # print_warning(\"No NLU data present.",
"Args: file_importer: `TrainingDataImporter` which supplies the training data. train_path: Directory",
"if not force_training: fingerprint_comparison = model.should_retrain( new_fingerprint, old_model, train_path )",
"as stack: models = {} from rasa.nlu import config as",
"domain = await file_importer.get_domain() # if domain.is_empty(): # return await",
"because no valid domain file was found. Only an nlu-model",
"a Core model. Args: domain: Path to the domain file.",
"the '--stories' argument.\" ) return return await _train_core_with_validated_data( file_importer, output=output,",
"model. Returns: If `train_path` is given it returns the path",
"retrain NLU model.\", color=bcolors.OKBLUE, ) def train_core( domain: Union[Domain, Text],",
"file_importer.get_config() ) await rasa.core.train( domain_file=domain, training_resource=file_importer, output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME), policy_config=config, additional_arguments=additional_arguments,",
"\"\"\"Train Core with validated training and config data.\"\"\" import rasa.core.train",
"training_files: Paths to the training data for Core and NLU.",
"domain: Path to the domain file. config: Path to the",
"print_error( \"No NLU data given. Please provide NLU data in",
"Dict from rasa.importers.importer import TrainingDataImporter from rasa import model from",
"\" # \"order to train a Rasa model using the",
"exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # normal (not compare) training print_color(\"Training",
"DEFAULT_CORE_SUBDIRECTORY_NAME), policy_config=config, additional_arguments=additional_arguments, ) print_color(\"Core model training completed.\", color=bcolors.OKBLUE) if",
"None, persist_nlu_training_data: bool = False, ): if not nlu_data: print_error(",
"file exists.\" ) return nlu_model_only async def _train_async_internal( file_importer: TrainingDataImporter,",
"training files still have to be selected file_importer = TrainingDataImporter.load_nlu_importer_from_config(",
"elif fingerprint_comparison_result.should_retrain_nlg(): print_color( \"Core stories/configuration did not change. \" \"Only",
"else: print_color( \"NLU data/configuration did not change. No need to",
"\"Nothing changed. You can use the old model stored at",
"loop.run_until_complete( train_async( domain=domain, config=config, training_files=training_files, output_path=output, force_training=force_training, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments,",
"training data should be persisted with the model. fixed_model_name: Name",
"FingerprintComparisonResult() if fingerprint_comparison_result.should_retrain_core(): await _train_core_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments,",
"the path to the directory with the trained model files.",
"None, persist_nlu_training_data: bool = False, retrain_nlu: Union[bool, List[Text]] = True",
"# config, domain, training_files # ) with ExitStack() as stack:",
"if not await file_importer.get_stories(): print_error( \"No stories given. Please provide",
"file_importer = TrainingDataImporter.load_nlu_importer_from_config( config, training_data_paths=[nlu_data] ) training_datas = await file_importer.get_nlu_data()",
"model stored at '{}'.\" \"\".format(os.path.abspath(old_model)) ) return old_model async def",
"Optional[Union[Text, List[Text]]], output_path: Text = DEFAULT_MODELS_PATH, force_training: bool = False,",
"= await asyncio.gather( file_importer.get_stories(), file_importer.get_nlu_data() ) # if stories.is_empty() and",
"Optional[Text] = None, persist_nlu_training_data: bool = False, ) -> Optional[Text]:",
"fixed_model_name=fixed_model_name, # additional_arguments=additional_arguments, # ) new_fingerprint = await model.model_fingerprint(file_importer) old_model",
"in the provided directory. fixed_model_name: Name of model to be",
"training_data_paths=[nlu_data] ) training_datas = await file_importer.get_nlu_data() if training_datas.is_empty(): print_error( f\"Path",
"config: if config[lang]: print_color(\"Start training {} NLU model ...\".format(lang), color=bcolors.OKBLUE)",
"on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod config =",
"bf mod from rasa_addons.importers import BotfrontFileImporter file_importer = BotfrontFileImporter(config, domain,",
"train_path=train_path, fingerprint_comparison_result=fingerprint_comparison, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) return model.package_model( fingerprint=new_fingerprint, output_directory=output_path,",
"\"\"\"Trains an NLU model. Args: config: Path to the config",
") -> Optional[Text]: if loop is None: try: loop =",
"if train_path: # If the train path was provided, do",
"model. fixed_model_name: Name of model to be stored. additional_arguments: Additional",
"_train_core_with_validated_data( # file_importer, # output=output_path, # fixed_model_name=fixed_model_name, # additional_arguments=additional_arguments, #",
"Text, fingerprint_comparison_result: Optional[FingerprintComparisonResult] = None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data:",
"def train_core( domain: Union[Domain, Text], config: Text, stories: Text, output:",
"_train_path, fixed_model_name=\"nlu-{}\".format(lang), persist_nlu_training_data=persist_nlu_training_data, ) else: print_color(\"NLU data for language <{}>",
"was provided, do nothing on exit. _train_path = train_path else:",
"`None` the model will be trained in a temporary directory,",
"model.package_model( fingerprint=new_fingerprint, output_directory=output_path, train_path=train_path, fixed_model_name=fixed_model_name, ) print_success( \"Nothing changed. You",
"async def _train_nlu_async( config: Text, nlu_data: Text, output: Text, train_path:",
"bf mod if fingerprint_comparison.is_training_required(): await _do_training( file_importer, output_path=output_path, train_path=train_path, fingerprint_comparison_result=fingerprint_comparison,",
"List, Union, Dict from rasa.importers.importer import TrainingDataImporter from rasa import",
"mod print_color(\"NLU model training completed.\", color=bcolors.OKBLUE) if train_path is None:",
"nlu_data: Text, output: Text, train_path: Optional[Text] = None, fixed_model_name: Optional[Text]",
"training completed.\", color=bcolors.OKBLUE) if train_path is None: # Only NLU",
"List[Text]], output: Text = DEFAULT_MODELS_PATH, force_training: bool = False, fixed_model_name:",
"config file for NLU. nlu_data: Path to the NLU training",
"asyncio.get_event_loop() except RuntimeError: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) return loop.run_until_complete( train_async(",
"return _train_path def train_nlu( config: Text, nlu_data: Text, output: Text,",
"nlu_untrainable] if core_untrainable: print_color(\"Skipping Core training since domain or stories",
"domain, training_files) # domain = await file_importer.get_domain() # if domain.is_empty():",
"it up on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # normal (not",
"training was skipped because no valid domain file was found.",
"Additional training parameters. Returns: If `train_path` is given it returns",
"fixed_model_name: Name of model to be stored. uncompress: If `True`",
"be selected file_importer = TrainingDataImporter.load_nlu_importer_from_config( config, training_data_paths=[nlu_data] ) training_datas =",
"a Rasa model (Core and NLU). Args: domain: Path to",
"domain using '--domain' argument or check if the provided domain",
"and config data.\"\"\" import rasa.core.train with ExitStack() as stack: if",
"new_fingerprint = await model.model_fingerprint(file_importer) old_model = model.get_latest_model(output_path) fingerprint_comparison = FingerprintComparisonResult(force_training=force_training)",
"config data.\"\"\" import rasa.core.train with ExitStack() as stack: if train_path:",
"rasa.core.train( domain_file=domain, training_resource=file_importer, output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME), policy_config=config, additional_arguments=additional_arguments, ) print_color(\"Core model",
"# if domain.is_empty(): # return await handle_domain_if_not_exists( # file_importer, output_path,",
"\" \"Please verify the data format. \" \"The NLU model",
"to the Core training data. output: Output path. train_path: If",
"None, persist_nlu_training_data: bool = False, additional_arguments: Optional[Dict] = None, )",
"models = {} from rasa.nlu import config as cfg_loader if",
"Rasa Core model using the '--stories' argument.\" ) return return",
"\"\"\" # file_importer = TrainingDataImporter.load_from_config( # config, domain, training_files #",
"Optional[Text] = None, persist_nlu_training_data: bool = False, retrain_nlu: Union[bool, List[Text]]",
"training_datas = await file_importer.get_nlu_data() if training_datas.is_empty(): print_error( f\"Path '{nlu_data}' doesn't",
"Please provide stories in order to \" \"train a Rasa",
"= [l for l in fingerprint_comparison.nlu if l not in",
"Path to the domain file. config: Dict of paths to",
"fixed_model_name ): nlu_model_only = await _train_nlu_with_validated_data( file_importer, output=output_path, fixed_model_name=fixed_model_name )",
"NLU data in \" # \"order to train a Rasa",
"the model. fixed_model_name: Name of model to be stored. additional_arguments:",
"train_path else: # Otherwise, create a temp train path and",
"Keys are language codes training_files: Paths to the training data",
"# file_importer, # output=output_path, # fixed_model_name=fixed_model_name, # additional_arguments=additional_arguments, # )",
"Rasa model using the '--data' argument.\" # ) # return",
"'--data' argument.\" # ) # return # if nlu_data.is_empty(): #",
"`True` the model will not be compressed. additional_arguments: Additional training",
"model_prefix=\"core-\", ) return _train_path def train_nlu( config: Text, nlu_data: Text,",
"model using the '--nlu' argument.\" ) return # training NLU",
"train the model. output_path: Output path. force_training: If `True` retrain",
"the provided directory. fixed_model_name: Name of model to be stored.",
"= False, additional_arguments: Optional[Dict] = None, ): if not fingerprint_comparison_result:",
"await _train_nlu_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, retrain_nlu=fingerprint_comparison_result.nlu, persist_nlu_training_data=persist_nlu_training_data, ) else:",
"nlu_data.items() if d.is_empty()] fingerprint_comparison.core = fingerprint_comparison.core and not core_untrainable fingerprint_comparison.nlu",
"and clean it up on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) #",
"provide stories and NLU data in \" # \"order to",
"True with list of all langs fingerprint_comparison.nlu = list(new_fingerprint.get(\"nlu-config\", {}).keys())",
"config, domain, training_files # ) with ExitStack() as stack: train_path",
"\" \"a Rasa NLU model using the '--nlu' argument.\" )",
"did not change. No need to retrain Core model.\", color=bcolors.OKBLUE,",
"replace True with list of all langs fingerprint_comparison.nlu = list(new_fingerprint.get(\"nlu-config\",",
"file_importer, output_path, fixed_model_name # ) # /bf mod return await",
"domain=domain, config=config, training_files=training_files, output_path=output, force_training=force_training, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) )",
"be persisted with the model. additional_arguments: Additional training parameters. Returns:",
"_train_async_internal( file_importer, train_path, output_path, force_training, fixed_model_name, persist_nlu_training_data, additional_arguments, ) async",
"(Core and NLU). Use only from `train_async`. Args: file_importer: `TrainingDataImporter`",
"have to be selected file_importer = TrainingDataImporter.load_nlu_importer_from_config( config, training_data_paths=[nlu_data] )",
"def handle_domain_if_not_exists( file_importer: TrainingDataImporter, output_path, fixed_model_name ): nlu_model_only = await",
"stored. uncompress: If `True` the model will not be compressed.",
"if domain.is_empty(): # return await handle_domain_if_not_exists( # file_importer, output_path, fixed_model_name",
"= None, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: loop",
"new_fingerprint, old_model, train_path ) # bf mod > if fingerprint_comparison.nlu",
"await _train_core_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) async def",
"persist_nlu_training_data: `True` if the NLU training data should be persisted",
"if fingerprint_comparison_result.should_retrain_nlu(): await _train_nlu_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, retrain_nlu=fingerprint_comparison_result.nlu, persist_nlu_training_data=persist_nlu_training_data,",
"the '--data' argument.\" # ) # return # if nlu_data.is_empty():",
"was trained. new_fingerprint = await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output,",
"\" \"Please specify a valid domain using '--domain' argument or",
"exit. _train_path = train_path else: # Otherwise, create a temp",
"# /bf mod print_color(\"NLU model training completed.\", color=bcolors.OKBLUE) if train_path",
"print_color(\"Skipping Core training since domain or stories are empty.\", color=bcolors.OKBLUE)",
"domain=domain, config=config, stories=stories, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) ) async",
"retrain Core model.\", color=bcolors.OKBLUE, ) if fingerprint_comparison_result.should_retrain_nlu(): await _train_nlu_with_validated_data( file_importer,",
"stories: Text, output: Text, train_path: Optional[Text] = None, fixed_model_name: Optional[Text]",
"the data format. \" \"The NLU model training will be",
"for Core. stories: Path to the Core training data. output:",
"Dict of paths to the config for Core and NLU.",
"handle_domain_if_not_exists( # file_importer, output_path, fixed_model_name # ) # /bf mod",
"Rasa model (Core and NLU). Use only from `train_async`. Args:",
"to train \" \"a Rasa NLU model using the '--nlu'",
"if config[lang]: print_color(\"Start training {} NLU model ...\".format(lang), color=bcolors.OKBLUE) _,",
"a temporary directory, otherwise in the provided directory. fixed_model_name: Name",
"training completed.\", color=bcolors.OKBLUE) if train_path is None: # Only Core",
"model will be trained.\") # return await _train_core_with_validated_data( # file_importer,",
"core_untrainable = domain.is_empty() or stories.is_empty() nlu_untrainable = [l for l,",
"list of all langs fingerprint_comparison.nlu = list(new_fingerprint.get(\"nlu-config\", {}).keys()) domain =",
"await file_importer.get_nlu_data() if training_datas.is_empty(): print_error( f\"Path '{nlu_data}' doesn't contain valid",
"with the trained model files. \"\"\" file_importer = TrainingDataImporter.load_core_importer_from_config( config,",
"return None if not await file_importer.get_stories(): print_error( \"No stories given.",
"-> Optional[Text]: loop = asyncio.get_event_loop() return loop.run_until_complete( train_core_async( domain=domain, config=config,",
"rasa.model import FingerprintComparisonResult from rasa.core.domain import Domain from rasa.utils.common import",
"NLU training data should be persisted with the model. Returns:",
"the model will not be compressed. additional_arguments: Additional training parameters.",
"the NLU training data should be persisted with the model.",
"the directory with the trained model files. \"\"\" loop =",
"# Otherwise, create a temp train path and clean it",
"training data. train_path: Directory in which to train the model.",
"= None, ) -> Optional[Text]: \"\"\"Trains a Rasa model (Core",
"= await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"nlu-\",",
"given it returns the path to the model archive, otherwise",
") # /bf mod return await _train_async_internal( file_importer, train_path, output_path,",
"additional_arguments=additional_arguments, # ) new_fingerprint = await model.model_fingerprint(file_importer) old_model = model.get_latest_model(output_path)",
"= FingerprintComparisonResult(force_training=force_training) if not force_training: fingerprint_comparison = model.should_retrain( new_fingerprint, old_model,",
"a Rasa model (Core and NLU). Use only from `train_async`.",
"fingerprint_comparison.nlu = list(new_fingerprint.get(\"nlu-config\", {}).keys()) domain = await file_importer.get_domain() core_untrainable =",
"= await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"core-\",",
"fixed_model_name=fixed_model_name, ) print_success( \"Nothing changed. You can use the old",
"persisted with the model. additional_arguments: Additional training parameters. Returns: Path",
"provided directory. fixed_model_name: Name of model to be stored. uncompress:",
"Core and NLU. output_path: Output path. force_training: If `True` retrain",
"color=bcolors.OKBLUE) if train_path is None: # Only NLU was trained",
"model. additional_arguments: Additional training parameters. Returns: Path of the trained",
"Optional[Text]: \"\"\"Train Core with validated training and config data.\"\"\" import",
"color=bcolors.OKBLUE, ) def train_core( domain: Union[Domain, Text], config: Text, stories:",
"mod config = await file_importer.get_nlu_config(retrain_nlu) for lang in config: if",
"DEFAULT_MODELS_PATH, DEFAULT_CORE_SUBDIRECTORY_NAME def train( domain: Text, config: Text, training_files: Union[Text,",
"Output path. train_path: If `None` the model will be trained",
"NLU. nlu_data: Path to the NLU training data. output: Output",
"persist_nlu_training_data, ) ) async def _train_nlu_async( config: Text, nlu_data: Text,",
"NLU with validated training and config data.\"\"\" import rasa.nlu.train with",
"with validated training and config data.\"\"\" import rasa.core.train with ExitStack()",
"path to the model archive, otherwise the path to the",
"color=bcolors.OKBLUE) _, models[lang], _ = await rasa.nlu.train( config[lang], file_importer, _train_path,",
"training parameters. Returns: If `train_path` is given it returns the",
"directory with the trained model files. \"\"\" file_importer = TrainingDataImporter.load_core_importer_from_config(",
"trained model files. \"\"\" file_importer = TrainingDataImporter.load_core_importer_from_config( config, domain, [stories]",
"as cfg_loader if train_path: # If the train path was",
"or stories are empty.\", color=bcolors.OKBLUE) for lang in nlu_untrainable: print_color(\"No",
"persist_nlu_training_data: bool = False, additional_arguments: Optional[Dict] = None, ) ->",
"train \" \"a Rasa NLU model using the '--nlu' argument.\"",
"language codes training_files: Paths to the training data for Core",
"parameters. Returns: Path of the trained model archive. \"\"\" #",
") # if stories.is_empty() and nlu_data.is_empty(): # print_error( # \"No",
"and NLU). Args: domain: Path to the domain file. config:",
"-> Optional[Text]: \"\"\"Trains an NLU model. Args: config: Path to",
"the NLU training data. output: Output path. train_path: If `None`",
"data for Core and NLU. output_path: Output path. force_training: If",
"file_importer, output=output_path, fixed_model_name=fixed_model_name ) print_warning( \"Core training was skipped because",
"rasa import model from rasa.model import FingerprintComparisonResult from rasa.core.domain import",
"language <{}>, skipping training...\".format(lang), color=bcolors.OKBLUE) # </ bf mod if",
"loop is None: try: loop = asyncio.get_event_loop() except RuntimeError: loop",
"as stack: if train_path: # If the train path was",
") return return await _train_nlu_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data,",
"of the trained model archive. \"\"\" stories, nlu_data = await",
"_train_async_internal( file_importer: TrainingDataImporter, train_path: Text, output_path: Text, force_training: bool, fixed_model_name:",
"NLU data in order to train \" \"a Rasa NLU",
"= await file_importer.get_nlu_data() if training_datas.is_empty(): print_error( f\"Path '{nlu_data}' doesn't contain",
"of the model to be stored. persist_nlu_training_data: `True` if the",
"bf mod config = await file_importer.get_nlu_config(retrain_nlu) for lang in config:",
") async def _train_core_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path: Optional[Text]",
"bool, fixed_model_name: Optional[Text], persist_nlu_training_data: bool, additional_arguments: Optional[Dict], ) -> Optional[Text]:",
"stories, nlu_data = await asyncio.gather( file_importer.get_stories(), file_importer.get_nlu_data() ) # if",
"Core was trained. new_fingerprint = await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint,",
"fingerprint=new_fingerprint, output_directory=output_path, train_path=train_path, fixed_model_name=fixed_model_name, ) print_success( \"Nothing changed. You can",
"a valid domain using '--domain' argument or check if the",
"loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) return loop.run_until_complete( train_async( domain=domain, config=config, training_files=training_files,",
"trained model archive. \"\"\" stories, nlu_data = await asyncio.gather( file_importer.get_stories(),",
") return old_model async def _do_training( file_importer: TrainingDataImporter, output_path: Text,",
"print_color( \"NLU data/configuration did not change. No need to retrain",
"file for NLU. nlu_data: Path to the NLU training data.",
"= None, loop: Optional[asyncio.AbstractEventLoop] = None, ) -> Optional[Text]: if",
"the trained model archive. \"\"\" stories, nlu_data = await asyncio.gather(",
"= model.should_retrain( new_fingerprint, old_model, train_path ) # bf mod >",
"\" \"The NLU model training will be skipped now.\" )",
"in nlu_data.items() if d.is_empty()] fingerprint_comparison.core = fingerprint_comparison.core and not core_untrainable",
"'--stories' argument.\" ) return return await _train_core_with_validated_data( file_importer, output=output, train_path=train_path,",
"# file_importer = TrainingDataImporter.load_from_config( # config, domain, training_files # )",
"import TempDirectoryPath from rasa.cli.utils import ( print_success, print_warning, print_error, bcolors,",
"\"No NLU data given. Please provide NLU data in order",
"fingerprint_comparison_result.should_retrain_core(): await _train_core_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) elif",
") await rasa.core.train( domain_file=domain, training_resource=file_importer, output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME), policy_config=config, additional_arguments=additional_arguments, )",
"not be compressed. additional_arguments: Additional training parameters. Returns: If `train_path`",
"completed.\", color=bcolors.OKBLUE) if train_path is None: # Only Core was",
"await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"nlu-\", )",
"training NLU only hence the training files still have to",
"be persisted with the model. Returns: If `train_path` is given",
"train_async( domain=domain, config=config, training_files=training_files, output_path=output, force_training=force_training, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, )",
"to the NLU training data. output: Output path. train_path: If",
"data in \" # \"order to train a Rasa model",
"rasa.nlu import config as cfg_loader if train_path: # If the",
"has not changed. fixed_model_name: Name of model to be stored.",
"def _do_training( file_importer: TrainingDataImporter, output_path: Text, train_path: Text, fingerprint_comparison_result: Optional[FingerprintComparisonResult]",
"else: # Otherwise, create a temp train path and clean",
"train_path is None: # Only NLU was trained new_fingerprint =",
"trained model archive. \"\"\" # file_importer = TrainingDataImporter.load_from_config( # config,",
"with validated training and config data.\"\"\" import rasa.nlu.train with ExitStack()",
"If the train path was provided, do nothing on exit.",
"Text, training_files: Union[Text, List[Text]], output: Text = DEFAULT_MODELS_PATH, force_training: bool",
"`True` retrain model even if data has not changed. persist_nlu_training_data:",
"in fingerprint_comparison.nlu if l not in nlu_untrainable] if core_untrainable: print_color(\"Skipping",
"fixed_model_name: Name of model to be stored. additional_arguments: Additional training",
"Path to the domain file. config: Path to the config",
"for NLU. nlu_data: Path to the NLU training data. output:",
"using '--domain' argument or check if the provided domain file",
"Optional[Text], persist_nlu_training_data: bool, additional_arguments: Optional[Dict], ) -> Optional[Text]: \"\"\"Trains a",
"the path to the model archive, otherwise the path to",
"domain or stories are empty.\", color=bcolors.OKBLUE) for lang in nlu_untrainable:",
"for language <{}>, skipping training...\".format(lang), color=bcolors.OKBLUE) # </ bf mod",
"found. \" \"Please specify a valid domain using '--domain' argument",
"output: Output path. train_path: If `None` the model will be",
"output_path=output_path, train_path=train_path, fingerprint_comparison_result=fingerprint_comparison, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) return model.package_model( fingerprint=new_fingerprint,",
"List[Text]]], output_path: Text = DEFAULT_MODELS_PATH, force_training: bool = False, fixed_model_name:",
"not change. \" \"Only the templates section has been changed.",
"await asyncio.gather( file_importer.get_stories(), file_importer.get_nlu_data() ) # if stories.is_empty() and nlu_data.is_empty():",
"if the NLU training data should be persisted with the",
"await handle_domain_if_not_exists( # file_importer, output_path, fixed_model_name # ) # /bf",
"= domain.is_empty() or stories.is_empty() nlu_untrainable = [l for l, d",
"should be persisted with the model. additional_arguments: Additional training parameters.",
"up on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod config",
"): if not fingerprint_comparison_result: fingerprint_comparison_result = FingerprintComparisonResult() if fingerprint_comparison_result.should_retrain_core(): await",
"output_path=output, force_training=force_training, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) ) async def train_async(",
"retrain model even if data has not changed. fixed_model_name: Name",
"asyncio.get_event_loop() return loop.run_until_complete( train_core_async( domain=domain, config=config, stories=stories, output=output, train_path=train_path, fixed_model_name=fixed_model_name,",
"async def _do_training( file_importer: TrainingDataImporter, output_path: Text, train_path: Text, fingerprint_comparison_result:",
"stored. additional_arguments: Additional training parameters. Returns: Path of the trained",
"valid domain file was found. \" \"Please specify a valid",
"config, domain, [stories] ) domain = await file_importer.get_domain() if domain.is_empty():",
"model even if data has not changed. persist_nlu_training_data: `True` if",
") -> Optional[Text]: \"\"\"Train NLU with validated training and config",
"'{}'.\" \"\".format(os.path.abspath(old_model)) ) return old_model async def _do_training( file_importer: TrainingDataImporter,",
"(not compare) training print_color(\"Training Core model...\", color=bcolors.OKBLUE) domain, config =",
"# print_error( # \"No training data given. Please provide stories",
"training print_color(\"Training Core model...\", color=bcolors.OKBLUE) domain, config = await asyncio.gather(",
"config for Core and NLU. Keys are language codes training_files:",
"fingerprint_comparison = FingerprintComparisonResult(force_training=force_training) if not force_training: fingerprint_comparison = model.should_retrain( new_fingerprint,",
"mod if fingerprint_comparison.is_training_required(): await _do_training( file_importer, output_path=output_path, train_path=train_path, fingerprint_comparison_result=fingerprint_comparison, fixed_model_name=fixed_model_name,",
"persist_nlu_training_data: bool = False, ) -> Optional[Text]: \"\"\"Trains an NLU",
"additional_arguments=additional_arguments, ) ) async def train_async( domain: Union[Domain, Text], config:",
"Optional[Dict] = None, loop: Optional[asyncio.AbstractEventLoop] = None, ) -> Optional[Text]:",
"model. output_path: Output path. force_training: If `True` retrain model even",
"rasa.constants import DEFAULT_MODELS_PATH, DEFAULT_CORE_SUBDIRECTORY_NAME def train( domain: Text, config: Text,",
"Name of model to be stored. additional_arguments: Additional training parameters.",
"output=output, train_path=train_path, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, ) async def _train_nlu_with_validated_data( file_importer: TrainingDataImporter,",
"\"Core stories/configuration did not change. No need to retrain Core",
"If `train_path` is given it returns the path to the",
"Core model. Args: domain: Path to the domain file. config:",
"be compressed. additional_arguments: Additional training parameters. Returns: If `train_path` is",
"NLU). Use only from `train_async`. Args: file_importer: `TrainingDataImporter` which supplies",
"model.\", color=bcolors.OKBLUE, ) if fingerprint_comparison_result.should_retrain_nlu(): await _train_nlu_with_validated_data( file_importer, output=output_path, train_path=train_path,",
"fixed_model_name=fixed_model_name ) print_warning( \"Core training was skipped because no valid",
"stories/configuration did not change. \" \"Only the templates section has",
"TrainingDataImporter, output_path: Text, train_path: Text, fingerprint_comparison_result: Optional[FingerprintComparisonResult] = None, fixed_model_name:",
"for Core and NLU. output_path: Output path. force_training: If `True`",
"file_importer.get_domain() if domain.is_empty(): print_error( \"Core training was skipped because no",
"training_files) # domain = await file_importer.get_domain() # if domain.is_empty(): #",
"print_success, print_warning, print_error, bcolors, print_color, ) from rasa.constants import DEFAULT_MODELS_PATH,",
"stories/configuration did not change. No need to retrain Core model.\",",
"config: Text, nlu_data: Text, output: Text, train_path: Optional[Text] = None,",
") async def handle_domain_if_not_exists( file_importer: TrainingDataImporter, output_path, fixed_model_name ): nlu_model_only",
"if the provided domain file exists.\" ) return nlu_model_only async",
"fingerprint_comparison.core and not core_untrainable fingerprint_comparison.nlu = [l for l in",
"given. Please provide NLU data in order to train \"",
"config=config, training_files=training_files, output_path=output, force_training=force_training, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) ) async",
"of the trained model archive. \"\"\" # file_importer = TrainingDataImporter.load_from_config(",
"None, persist_nlu_training_data: bool = False, additional_arguments: Optional[Dict] = None, ):",
"nlu_model_only async def _train_async_internal( file_importer: TrainingDataImporter, train_path: Text, output_path: Text,",
"d.is_empty()] fingerprint_comparison.core = fingerprint_comparison.core and not core_untrainable fingerprint_comparison.nlu = [l",
"file was found. Only an nlu-model was created.\" \"Please specify",
"additional_arguments=additional_arguments, ) async def _train_core_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path:",
"await file_importer.get_nlu_config(retrain_nlu) for lang in config: if config[lang]: print_color(\"Start training",
"model (Core and NLU). Use only from `train_async`. Args: file_importer:",
"provided directory. fixed_model_name: Name of the model to be stored.",
"training and config data.\"\"\" import rasa.nlu.train with ExitStack() as stack:",
"= fingerprint_comparison.core and not core_untrainable fingerprint_comparison.nlu = [l for l",
"NLU data found for language <{}>, skipping training...\".format(lang), color=bcolors.OKBLUE) #",
"or check if the provided domain file exists.\" ) return",
"_train_core_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path: Optional[Text] = None, fixed_model_name:",
") async def train_core_async( domain: Union[Domain, Text], config: Text, stories:",
"f\"Path '{nlu_data}' doesn't contain valid NLU data in it. \"",
"even if data has not changed. persist_nlu_training_data: `True` if the",
"was trained new_fingerprint = await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output,",
"from contextlib import ExitStack from typing import Text, Optional, List,",
"= TrainingDataImporter.load_from_config( # config, domain, training_files # ) with ExitStack()",
"training {} NLU model ...\".format(lang), color=bcolors.OKBLUE) _, models[lang], _ =",
"return await handle_domain_if_not_exists( # file_importer, output_path, fixed_model_name # ) #",
"in nlu_untrainable: print_color(\"No NLU data found for language <{}>, skipping",
"since domain or stories are empty.\", color=bcolors.OKBLUE) for lang in",
"persist_nlu_training_data: bool = False, ): if not nlu_data: print_error( \"No",
"return old_model async def _do_training( file_importer: TrainingDataImporter, output_path: Text, train_path:",
"Directory in which to train the model. output_path: Output path.",
"file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, ) async def _train_nlu_with_validated_data( file_importer:",
"_, models[lang], _ = await rasa.nlu.train( config[lang], file_importer, _train_path, fixed_model_name=\"nlu-{}\".format(lang),",
"has been changed. A new model with \" \"the updated",
"\"the updated templates will be created.\", color=bcolors.OKBLUE, ) await model.update_model_with_new_domain(file_importer,",
"= False, ): if not nlu_data: print_error( \"No NLU data",
"be persisted with the model. fixed_model_name: Name of model to",
"additional_arguments: Optional[Dict] = None, ): if not fingerprint_comparison_result: fingerprint_comparison_result =",
"loop = asyncio.get_event_loop() return loop.run_until_complete( train_core_async( domain=domain, config=config, stories=stories, output=output,",
"If `True` the model will not be compressed. additional_arguments: Additional",
"\"Core training was skipped because no valid domain file was",
"bool, additional_arguments: Optional[Dict], ) -> Optional[Text]: \"\"\"Trains a Rasa model",
") return _train_path def train_nlu( config: Text, nlu_data: Text, output:",
"training_resource=file_importer, output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME), policy_config=config, additional_arguments=additional_arguments, ) print_color(\"Core model training completed.\",",
"\"The NLU model training will be skipped now.\" ) return",
"to be stored. additional_arguments: Additional training parameters. Returns: Path of",
"file_importer.get_stories(), file_importer.get_nlu_data() ) # if stories.is_empty() and nlu_data.is_empty(): # print_error(",
"model. Args: domain: Path to the domain file. config: Path",
"ExitStack() as stack: train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod from",
"of paths to the config for Core and NLU. Keys",
"color=bcolors.OKBLUE) # </ bf mod if fingerprint_comparison.is_training_required(): await _do_training( file_importer,",
"a Rasa model using the '--data' argument.\" # ) #",
"= None, persist_nlu_training_data: bool = False, retrain_nlu: Union[bool, List[Text]] =",
"model to be stored. uncompress: If `True` the model will",
"train_path, fixed_model_name, persist_nlu_training_data, ) ) async def _train_nlu_async( config: Text,",
"False, ): if not nlu_data: print_error( \"No NLU data given.",
"train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) async def _train_core_with_validated_data( file_importer: TrainingDataImporter, output:",
"_ = await rasa.nlu.train( config[lang], file_importer, _train_path, fixed_model_name=\"nlu-{}\".format(lang), persist_nlu_training_data=persist_nlu_training_data, )",
"is None: # Only NLU was trained new_fingerprint = await",
"the trained model files. \"\"\" file_importer = TrainingDataImporter.load_core_importer_from_config( config, domain,",
"fixed_model_name: Name of model to be stored. persist_nlu_training_data: `True` if",
"bool = False, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]:",
"fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) elif fingerprint_comparison_result.should_retrain_nlg(): print_color( \"Core stories/configuration did not",
"model archive. \"\"\" stories, nlu_data = await asyncio.gather( file_importer.get_stories(), file_importer.get_nlu_data()",
"Optional[Text] = None, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]:",
"fixed_model_name=\"nlu-{}\".format(lang), persist_nlu_training_data=persist_nlu_training_data, ) else: print_color(\"NLU data for language <{}> didn't",
"data should be persisted with the model. additional_arguments: Additional training",
"config: Path to the config file for Core. stories: Path",
"doesn't contain valid NLU data in it. \" \"Please verify",
"not change. No need to retrain Core model.\", color=bcolors.OKBLUE, )",
"Optional, List, Union, Dict from rasa.importers.importer import TrainingDataImporter from rasa",
"If `None` the model will be trained in a temporary",
"the model. output_path: Output path. force_training: If `True` retrain model",
"which supplies the training data. train_path: Directory in which to",
"= await asyncio.gather( file_importer.get_domain(), file_importer.get_config() ) await rasa.core.train( domain_file=domain, training_resource=file_importer,",
"fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False, ): if",
"an nlu-model was created.\" \"Please specify a valid domain using",
"skipped now.\" ) return return await _train_nlu_with_validated_data( file_importer, output=output, train_path=train_path,",
"directory. fixed_model_name: Name of the model to be stored. persist_nlu_training_data:",
"else: print_color(\"NLU data for language <{}> didn't change, skipping training...\".format(lang),",
"validated training and config data.\"\"\" import rasa.core.train with ExitStack() as",
"config file for Core. stories: Path to the Core training",
"TrainingDataImporter, train_path: Text, output_path: Text, force_training: bool, fixed_model_name: Optional[Text], persist_nlu_training_data:",
"and NLU). Use only from `train_async`. Args: file_importer: `TrainingDataImporter` which",
"\"No stories given. Please provide stories in order to \"",
"model using the '--stories' argument.\" ) return return await _train_core_with_validated_data(",
"domain file. config: Dict of paths to the config for",
"Text], training_files: Optional[Union[Text, List[Text]]], output_path: Text = DEFAULT_MODELS_PATH, force_training: bool",
"exists.\" ) return nlu_model_only async def _train_async_internal( file_importer: TrainingDataImporter, train_path:",
"training data should be persisted with the model. additional_arguments: Additional",
"\"No training data given. Please provide stories and NLU data",
"model with \" \"the updated templates will be created.\", color=bcolors.OKBLUE,",
"model even if data has not changed. fixed_model_name: Name of",
"otherwise in the provided directory. fixed_model_name: Name of the model",
"need to retrain Core model.\", color=bcolors.OKBLUE, ) if fingerprint_comparison_result.should_retrain_nlu(): await",
"Core model.\", color=bcolors.OKBLUE, ) if fingerprint_comparison_result.should_retrain_nlu(): await _train_nlu_with_validated_data( file_importer, output=output_path,",
"the training data for Core and NLU. output_path: Output path.",
"# file_importer, output_path, fixed_model_name # ) # /bf mod return",
"paths to the config for Core and NLU. Keys are",
"= None, fixed_model_name: Optional[Text] = None, additional_arguments: Optional[Dict] = None,",
"did not change. No need to retrain NLU model.\", color=bcolors.OKBLUE,",
"'--nlu' argument.\" ) return # training NLU only hence the",
"be stored. additional_arguments: Additional training parameters. Returns: Path of the",
"= stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # normal (not compare) training print_color(\"Training Core model...\",",
"await rasa.nlu.train( config[lang], file_importer, _train_path, fixed_model_name=\"nlu-{}\".format(lang), persist_nlu_training_data=persist_nlu_training_data, ) else: print_color(\"NLU",
"empty.\", color=bcolors.OKBLUE) for lang in nlu_untrainable: print_color(\"No NLU data found",
"to be selected file_importer = TrainingDataImporter.load_nlu_importer_from_config( config, training_data_paths=[nlu_data] ) training_datas",
"try: loop = asyncio.get_event_loop() except RuntimeError: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop)",
"output_path: Output path. force_training: If `True` retrain model even if",
"persist_nlu_training_data: bool, additional_arguments: Optional[Dict], ) -> Optional[Text]: \"\"\"Trains a Rasa",
"return nlu_model_only async def _train_async_internal( file_importer: TrainingDataImporter, train_path: Text, output_path:",
"async def train_core_async( domain: Union[Domain, Text], config: Text, stories: Text,",
"the training files still have to be selected file_importer =",
"model files. \"\"\" loop = asyncio.get_event_loop() return loop.run_until_complete( _train_nlu_async( config,",
"rasa.nlu.train( config[lang], file_importer, _train_path, fixed_model_name=\"nlu-{}\".format(lang), persist_nlu_training_data=persist_nlu_training_data, ) else: print_color(\"NLU data",
"clean it up on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf",
"to the config for Core and NLU. Keys are language",
"file_importer, _train_path, fixed_model_name=\"nlu-{}\".format(lang), persist_nlu_training_data=persist_nlu_training_data, ) else: print_color(\"NLU data for language",
"be skipped now.\" ) return return await _train_nlu_with_validated_data( file_importer, output=output,",
"Text, Optional, List, Union, Dict from rasa.importers.importer import TrainingDataImporter from",
"Union[Text, List[Text]], output: Text = DEFAULT_MODELS_PATH, force_training: bool = False,",
"archive, otherwise the path to the directory with the trained",
"files. \"\"\" file_importer = TrainingDataImporter.load_core_importer_from_config( config, domain, [stories] ) domain",
"config = await file_importer.get_nlu_config(retrain_nlu) for lang in config: if config[lang]:",
"-> Optional[Text]: \"\"\"Trains a Rasa model (Core and NLU). Use",
"in order to \" \"train a Rasa Core model using",
"os import tempfile from contextlib import ExitStack from typing import",
"</ bf mod if fingerprint_comparison.is_training_required(): await _do_training( file_importer, output_path=output_path, train_path=train_path,",
"model files. \"\"\" file_importer = TrainingDataImporter.load_core_importer_from_config( config, domain, [stories] )",
"train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) elif fingerprint_comparison_result.should_retrain_nlg(): print_color( \"Core stories/configuration did",
"if d.is_empty()] fingerprint_comparison.core = fingerprint_comparison.core and not core_untrainable fingerprint_comparison.nlu =",
"...\".format(lang), color=bcolors.OKBLUE) _, models[lang], _ = await rasa.nlu.train( config[lang], file_importer,",
"= None, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Trains",
"fixed_model_name=fixed_model_name, model_prefix=\"core-\", ) return _train_path def train_nlu( config: Text, nlu_data:",
"Optional[Text]: \"\"\"Trains a Rasa model (Core and NLU). Args: domain:",
"train( domain: Text, config: Text, training_files: Union[Text, List[Text]], output: Text",
"verify the data format. \" \"The NLU model training will",
"retrain_nlu=fingerprint_comparison_result.nlu, persist_nlu_training_data=persist_nlu_training_data, ) else: print_color( \"NLU data/configuration did not change.",
"import ( print_success, print_warning, print_error, bcolors, print_color, ) from rasa.constants",
"valid domain file was found. Only an nlu-model was created.\"",
"Text, train_path: Optional[Text] = None, fixed_model_name: Optional[Text] = None, additional_arguments:",
"model from rasa.model import FingerprintComparisonResult from rasa.core.domain import Domain from",
"with \" \"the updated templates will be created.\", color=bcolors.OKBLUE, )",
") print_warning( \"Core training was skipped because no valid domain",
"Args: domain: Path to the domain file. config: Dict of",
"fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) return model.package_model( fingerprint=new_fingerprint, output_directory=output_path, train_path=train_path, fixed_model_name=fixed_model_name,",
"can use the old model stored at '{}'.\" \"\".format(os.path.abspath(old_model)) )",
"-> Optional[Text]: \"\"\"Train NLU with validated training and config data.\"\"\"",
"in the provided directory. fixed_model_name: Name of the model to",
"directory. fixed_model_name: Name of model to be stored. uncompress: If",
"Optional[Text]: \"\"\"Trains a Core model. Args: domain: Path to the",
"NLU was trained new_fingerprint = await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint,",
"NLU model using the '--nlu' argument.\" ) return # training",
"model to be stored. persist_nlu_training_data: `True` if the NLU training",
"valid domain using '--domain' argument or check if the provided",
"print_error( f\"Path '{nlu_data}' doesn't contain valid NLU data in it.",
"from `train_async`. Args: file_importer: `TrainingDataImporter` which supplies the training data.",
"None, fixed_model_name: Optional[Text] = None, additional_arguments: Optional[Dict] = None, )",
"NLU data present. Just a Rasa Core model will be",
"loop: Optional[asyncio.AbstractEventLoop] = None, ) -> Optional[Text]: if loop is",
"which to train the model. output_path: Output path. force_training: If",
"training data for Core and NLU. output_path: Output path. force_training:",
"_train_core_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) elif fingerprint_comparison_result.should_retrain_nlg(): print_color(",
"additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Trains a Core",
"data.\"\"\" import rasa.nlu.train with ExitStack() as stack: models = {}",
"stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod from rasa_addons.importers import BotfrontFileImporter file_importer =",
"force_training, fixed_model_name, persist_nlu_training_data, additional_arguments, ) async def handle_domain_if_not_exists( file_importer: TrainingDataImporter,",
"exists.\" ) return None if not await file_importer.get_stories(): print_error( \"No",
"fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) async def _train_core_with_validated_data( file_importer: TrainingDataImporter, output: Text,",
"= False, additional_arguments: Optional[Dict] = None, loop: Optional[asyncio.AbstractEventLoop] = None,",
"import Text, Optional, List, Union, Dict from rasa.importers.importer import TrainingDataImporter",
"BotfrontFileImporter file_importer = BotfrontFileImporter(config, domain, training_files) # domain = await",
"training data should be persisted with the model. Returns: If",
"order to train \" \"a Rasa NLU model using the",
"{} from rasa.nlu import config as cfg_loader if train_path: #",
"a Rasa Core model using the '--stories' argument.\" ) return",
"contain valid NLU data in it. \" \"Please verify the",
"stack: train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod from rasa_addons.importers import",
"def train_async( domain: Union[Domain, Text], config: Dict[Text, Text], training_files: Optional[Union[Text,",
"to the directory with the trained model files. \"\"\" loop",
"# output=output_path, # fixed_model_name=fixed_model_name, # additional_arguments=additional_arguments, # ) new_fingerprint =",
"not changed. fixed_model_name: Name of model to be stored. persist_nlu_training_data:",
"= None, ) -> Optional[Text]: \"\"\"Train Core with validated training",
"return # training NLU only hence the training files still",
"output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) elif fingerprint_comparison_result.should_retrain_nlg(): print_color( \"Core stories/configuration",
"to be stored. persist_nlu_training_data: `True` if the NLU training data",
") -> Optional[Text]: loop = asyncio.get_event_loop() return loop.run_until_complete( train_core_async( domain=domain,",
"None, persist_nlu_training_data: bool = False, additional_arguments: Optional[Dict] = None, loop:",
"model training will be skipped now.\" ) return return await",
"will be trained in a temporary directory, otherwise in the",
"data in it. \" \"Please verify the data format. \"",
"additional_arguments=additional_arguments, ) print_color(\"Core model training completed.\", color=bcolors.OKBLUE) if train_path is",
"return loop.run_until_complete( train_async( domain=domain, config=config, training_files=training_files, output_path=output, force_training=force_training, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data,",
"be stored. uncompress: If `True` the model will not be",
"is given it returns the path to the model archive,",
"the trained model archive. \"\"\" # file_importer = TrainingDataImporter.load_from_config( #",
"a Rasa Core model will be trained.\") # return await",
"# return await handle_domain_if_not_exists( # file_importer, output_path, fixed_model_name # )",
"bool = False, additional_arguments: Optional[Dict] = None, ): if not",
"asyncio.get_event_loop() return loop.run_until_complete( _train_nlu_async( config, nlu_data, output, train_path, fixed_model_name, persist_nlu_training_data,",
"\"a Rasa NLU model using the '--nlu' argument.\" ) return",
"model (Core and NLU). Args: domain: Path to the domain",
"`TrainingDataImporter` which supplies the training data. train_path: Directory in which",
"file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) async def _train_core_with_validated_data( file_importer:",
"domain, [stories] ) domain = await file_importer.get_domain() if domain.is_empty(): print_error(",
"training parameters. Returns: Path of the trained model archive. \"\"\"",
"training and config data.\"\"\" import rasa.core.train with ExitStack() as stack:",
"): if not nlu_data: print_error( \"No NLU data given. Please",
") async def _train_nlu_async( config: Text, nlu_data: Text, output: Text,",
"hence the training files still have to be selected file_importer",
"\"\"\"Trains a Rasa model (Core and NLU). Use only from",
"= None, persist_nlu_training_data: bool = False, ) -> Optional[Text]: \"\"\"Trains",
"Returns: If `train_path` is given it returns the path to",
") return # training NLU only hence the training files",
"await asyncio.gather( file_importer.get_domain(), file_importer.get_config() ) await rasa.core.train( domain_file=domain, training_resource=file_importer, output_path=os.path.join(_train_path,",
"not nlu_data: print_error( \"No NLU data given. Please provide NLU",
"'--domain' argument or check if the provided domain file exists.\"",
"otherwise in the provided directory. fixed_model_name: Name of model to",
"Union[bool, List[Text]] = True ) -> Optional[Text]: \"\"\"Train NLU with",
"print_color(\"NLU model training completed.\", color=bcolors.OKBLUE) if train_path is None: #",
"fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"core-\", ) return _train_path def train_nlu(",
"NLU training data should be persisted with the model. additional_arguments:",
"core_untrainable: print_color(\"Skipping Core training since domain or stories are empty.\",",
"await _train_nlu_with_validated_data( file_importer, output=output_path, fixed_model_name=fixed_model_name ) print_warning( \"Core training was",
"for lang in nlu_untrainable: print_color(\"No NLU data found for language",
"change, skipping training...\".format(lang), color=bcolors.OKBLUE) # /bf mod print_color(\"NLU model training",
"import rasa.core.train with ExitStack() as stack: if train_path: # If",
"has not changed. persist_nlu_training_data: `True` if the NLU training data",
"list(new_fingerprint.get(\"nlu-config\", {}).keys()) domain = await file_importer.get_domain() core_untrainable = domain.is_empty() or",
"nlu_untrainable: print_color(\"No NLU data found for language <{}>, skipping training...\".format(lang),",
"from rasa.core.domain import Domain from rasa.utils.common import TempDirectoryPath from rasa.cli.utils",
"bool = False, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool =",
"Only an nlu-model was created.\" \"Please specify a valid domain",
"train_async( domain: Union[Domain, Text], config: Dict[Text, Text], training_files: Optional[Union[Text, List[Text]]],",
"{} NLU model ...\".format(lang), color=bcolors.OKBLUE) _, models[lang], _ = await",
"domain: Union[Domain, Text], config: Text, stories: Text, output: Text, train_path:",
"color=bcolors.OKBLUE) for lang in nlu_untrainable: print_color(\"No NLU data found for",
"no valid domain file was found. Only an nlu-model was",
") return model.package_model( fingerprint=new_fingerprint, output_directory=output_path, train_path=train_path, fixed_model_name=fixed_model_name, ) print_success( \"Nothing",
"bf mod > if fingerprint_comparison.nlu == True: # replace True",
"the model. additional_arguments: Additional training parameters. Returns: Path of the",
") elif fingerprint_comparison_result.should_retrain_nlg(): print_color( \"Core stories/configuration did not change. \"",
"\"Core stories/configuration did not change. \" \"Only the templates section",
"persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) return model.package_model( fingerprint=new_fingerprint, output_directory=output_path, train_path=train_path, fixed_model_name=fixed_model_name, )",
"Dict[Text, Text], training_files: Optional[Union[Text, List[Text]]], output_path: Text = DEFAULT_MODELS_PATH, force_training:",
"changed. fixed_model_name: Name of model to be stored. persist_nlu_training_data: `True`",
"None: # Only NLU was trained new_fingerprint = await model.model_fingerprint(file_importer)",
"fingerprint_comparison_result: Optional[FingerprintComparisonResult] = None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool",
"data.\"\"\" import rasa.core.train with ExitStack() as stack: if train_path: #",
"Returns: Path of the trained model archive. \"\"\" stories, nlu_data",
"l not in nlu_untrainable] if core_untrainable: print_color(\"Skipping Core training since",
"= asyncio.new_event_loop() asyncio.set_event_loop(loop) return loop.run_until_complete( train_async( domain=domain, config=config, training_files=training_files, output_path=output,",
"domain = await file_importer.get_domain() core_untrainable = domain.is_empty() or stories.is_empty() nlu_untrainable",
"retrain model even if data has not changed. persist_nlu_training_data: `True`",
"# ) # /bf mod return await _train_async_internal( file_importer, train_path,",
"return await _train_core_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) async",
"output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME), policy_config=config, additional_arguments=additional_arguments, ) print_color(\"Core model training completed.\", color=bcolors.OKBLUE)",
"in config: if config[lang]: print_color(\"Start training {} NLU model ...\".format(lang),",
"No need to retrain Core model.\", color=bcolors.OKBLUE, ) if fingerprint_comparison_result.should_retrain_nlu():",
"print_color( \"Core stories/configuration did not change. No need to retrain",
"FingerprintComparisonResult(force_training=force_training) if not force_training: fingerprint_comparison = model.should_retrain( new_fingerprint, old_model, train_path",
"the config for Core and NLU. Keys are language codes",
"the directory with the trained model files. \"\"\" file_importer =",
"domain file was found. \" \"Please specify a valid domain",
"fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) ) async def train_async( domain: Union[Domain,",
"provide NLU data in order to train \" \"a Rasa",
"trained in a temporary directory, otherwise in the provided directory.",
"\"order to train a Rasa model using the '--data' argument.\"",
"check if the provided domain file exists.\" ) return nlu_model_only",
"Optional[Text]: \"\"\"Train NLU with validated training and config data.\"\"\" import",
"data given. Please provide stories and NLU data in \"",
"persist_nlu_training_data: bool = False, additional_arguments: Optional[Dict] = None, loop: Optional[asyncio.AbstractEventLoop]",
"TrainingDataImporter.load_from_config( # config, domain, training_files # ) with ExitStack() as",
"parameters. Returns: If `train_path` is given it returns the path",
"Union[Domain, Text], config: Text, stories: Text, output: Text, train_path: Optional[Text]",
"train_core_async( domain=domain, config=config, stories=stories, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) )",
"data given. Please provide NLU data in order to train",
"= await file_importer.get_domain() core_untrainable = domain.is_empty() or stories.is_empty() nlu_untrainable =",
"or stories.is_empty() nlu_untrainable = [l for l, d in nlu_data.items()",
"trained. new_fingerprint = await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path,",
"output=output_path, # fixed_model_name=fixed_model_name, # additional_arguments=additional_arguments, # ) new_fingerprint = await",
"= asyncio.get_event_loop() return loop.run_until_complete( train_core_async( domain=domain, config=config, stories=stories, output=output, train_path=train_path,",
"argument.\" ) return return await _train_core_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name,",
"not await file_importer.get_stories(): print_error( \"No stories given. Please provide stories",
"DEFAULT_CORE_SUBDIRECTORY_NAME def train( domain: Text, config: Text, training_files: Union[Text, List[Text]],",
"Please provide stories and NLU data in \" # \"order",
"found for language <{}>, skipping training...\".format(lang), color=bcolors.OKBLUE) # </ bf",
"of model to be stored. uncompress: If `True` the model",
"def _train_core_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path: Optional[Text] = None,",
"Optional[Text]: \"\"\"Trains a Rasa model (Core and NLU). Use only",
"domain: Union[Domain, Text], config: Dict[Text, Text], training_files: Optional[Union[Text, List[Text]]], output_path:",
"== True: # replace True with list of all langs",
"= False, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Trains",
"TrainingDataImporter, output: Text, train_path: Optional[Text] = None, fixed_model_name: Optional[Text] =",
"old_model = model.get_latest_model(output_path) fingerprint_comparison = FingerprintComparisonResult(force_training=force_training) if not force_training: fingerprint_comparison",
"Text], config: Dict[Text, Text], training_files: Optional[Union[Text, List[Text]]], output_path: Text =",
"await _train_async_internal( file_importer, train_path, output_path, force_training, fixed_model_name, persist_nlu_training_data, additional_arguments, )",
"skipped because no valid domain file was found. Only an",
"= None, ) -> Optional[Text]: if loop is None: try:",
"argument.\" # ) # return # if nlu_data.is_empty(): # print_warning(\"No",
"file_importer: TrainingDataImporter, train_path: Text, output_path: Text, force_training: bool, fixed_model_name: Optional[Text],",
"changed. persist_nlu_training_data: `True` if the NLU training data should be",
"model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"nlu-\", ) return",
"and nlu_data.is_empty(): # print_error( # \"No training data given. Please",
"_train_nlu_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path: Optional[Text] = None, fixed_model_name:",
"section has been changed. A new model with \" \"the",
"uncompress: If `True` the model will not be compressed. additional_arguments:",
"FingerprintComparisonResult from rasa.core.domain import Domain from rasa.utils.common import TempDirectoryPath from",
"domain.is_empty() or stories.is_empty() nlu_untrainable = [l for l, d in",
"codes training_files: Paths to the training data for Core and",
"policy_config=config, additional_arguments=additional_arguments, ) print_color(\"Core model training completed.\", color=bcolors.OKBLUE) if train_path",
"= None, persist_nlu_training_data: bool = False, ): if not nlu_data:",
"False, retrain_nlu: Union[bool, List[Text]] = True ) -> Optional[Text]: \"\"\"Train",
"# bf mod config = await file_importer.get_nlu_config(retrain_nlu) for lang in",
"the old model stored at '{}'.\" \"\".format(os.path.abspath(old_model)) ) return old_model",
"the model to be stored. persist_nlu_training_data: `True` if the NLU",
"stack: models = {} from rasa.nlu import config as cfg_loader",
"stories are empty.\", color=bcolors.OKBLUE) for lang in nlu_untrainable: print_color(\"No NLU",
"_train_path def train_nlu( config: Text, nlu_data: Text, output: Text, train_path:",
"nlu_data: print_error( \"No NLU data given. Please provide NLU data",
"in which to train the model. output_path: Output path. force_training:",
"be trained.\") # return await _train_core_with_validated_data( # file_importer, # output=output_path,",
"# bf mod > if fingerprint_comparison.nlu == True: # replace",
"config as cfg_loader if train_path: # If the train path",
"fingerprint_comparison_result.should_retrain_nlu(): await _train_nlu_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, retrain_nlu=fingerprint_comparison_result.nlu, persist_nlu_training_data=persist_nlu_training_data, )",
"path to the directory with the trained model files. \"\"\"",
"for l in fingerprint_comparison.nlu if l not in nlu_untrainable] if",
") if fingerprint_comparison_result.should_retrain_nlu(): await _train_nlu_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, retrain_nlu=fingerprint_comparison_result.nlu,",
"NLU model ...\".format(lang), color=bcolors.OKBLUE) _, models[lang], _ = await rasa.nlu.train(",
"output: Text = DEFAULT_MODELS_PATH, force_training: bool = False, fixed_model_name: Optional[Text]",
"Text, output_path: Text, force_training: bool, fixed_model_name: Optional[Text], persist_nlu_training_data: bool, additional_arguments:",
"to be stored. uncompress: If `True` the model will not",
"if training_datas.is_empty(): print_error( f\"Path '{nlu_data}' doesn't contain valid NLU data",
") new_fingerprint = await model.model_fingerprint(file_importer) old_model = model.get_latest_model(output_path) fingerprint_comparison =",
"mod return await _train_async_internal( file_importer, train_path, output_path, force_training, fixed_model_name, persist_nlu_training_data,",
"\"\"\" stories, nlu_data = await asyncio.gather( file_importer.get_stories(), file_importer.get_nlu_data() ) #",
"fixed_model_name: Optional[Text] = None, additional_arguments: Optional[Dict] = None, ) ->",
"Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Trains a Rasa model",
"domain file was found. Only an nlu-model was created.\" \"Please",
"Optional[Text]: if loop is None: try: loop = asyncio.get_event_loop() except",
"data in order to train \" \"a Rasa NLU model",
"the train path was provided, do nothing on exit. _train_path",
"with list of all langs fingerprint_comparison.nlu = list(new_fingerprint.get(\"nlu-config\", {}).keys()) domain",
"asyncio.gather( file_importer.get_stories(), file_importer.get_nlu_data() ) # if stories.is_empty() and nlu_data.is_empty(): #",
"color=bcolors.OKBLUE, ) if fingerprint_comparison_result.should_retrain_nlu(): await _train_nlu_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name,",
"path and clean it up on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp()))",
"data present. Just a Rasa Core model will be trained.\")",
"\" \"train a Rasa Core model using the '--stories' argument.\"",
"are language codes training_files: Paths to the training data for",
"was skipped because no valid domain file was found. \"",
"change. \" \"Only the templates section has been changed. A",
"TempDirectoryPath from rasa.cli.utils import ( print_success, print_warning, print_error, bcolors, print_color,",
") return None if not await file_importer.get_stories(): print_error( \"No stories",
"data found for language <{}>, skipping training...\".format(lang), color=bcolors.OKBLUE) # </",
"# fixed_model_name=fixed_model_name, # additional_arguments=additional_arguments, # ) new_fingerprint = await model.model_fingerprint(file_importer)",
"\"\"\"Trains a Core model. Args: domain: Path to the domain",
"present. Just a Rasa Core model will be trained.\") #",
"and NLU data in \" # \"order to train a",
"\"Please specify a valid domain using '--domain' argument or check",
"config, nlu_data, output, train_path, fixed_model_name, persist_nlu_training_data, ) ) async def",
"the templates section has been changed. A new model with",
"= await model.model_fingerprint(file_importer) old_model = model.get_latest_model(output_path) fingerprint_comparison = FingerprintComparisonResult(force_training=force_training) if",
"a temp train path and clean it up on exit.",
"fingerprint_comparison_result = FingerprintComparisonResult() if fingerprint_comparison_result.should_retrain_core(): await _train_core_with_validated_data( file_importer, output=output_path, train_path=train_path,",
"archive. \"\"\" # file_importer = TrainingDataImporter.load_from_config( # config, domain, training_files",
"`train_async`. Args: file_importer: `TrainingDataImporter` which supplies the training data. train_path:",
"the domain file. config: Dict of paths to the config",
"print_color(\"NLU data for language <{}> didn't change, skipping training...\".format(lang), color=bcolors.OKBLUE)",
"BotfrontFileImporter(config, domain, training_files) # domain = await file_importer.get_domain() # if",
"in \" # \"order to train a Rasa model using",
"Text, stories: Text, output: Text, train_path: Optional[Text] = None, fixed_model_name:",
"old model stored at '{}'.\" \"\".format(os.path.abspath(old_model)) ) return old_model async",
"fingerprint_comparison_result: fingerprint_comparison_result = FingerprintComparisonResult() if fingerprint_comparison_result.should_retrain_core(): await _train_core_with_validated_data( file_importer, output=output_path,",
"async def _train_nlu_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path: Optional[Text] =",
"Optional[Dict] = None, ): if not fingerprint_comparison_result: fingerprint_comparison_result = FingerprintComparisonResult()",
"fingerprint_comparison = model.should_retrain( new_fingerprint, old_model, train_path ) # bf mod",
"_train_nlu_with_validated_data( file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, retrain_nlu=fingerprint_comparison_result.nlu, persist_nlu_training_data=persist_nlu_training_data, ) else: print_color(",
"using the '--data' argument.\" # ) # return # if",
"await rasa.core.train( domain_file=domain, training_resource=file_importer, output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME), policy_config=config, additional_arguments=additional_arguments, ) print_color(\"Core",
"None, ) -> Optional[Text]: \"\"\"Trains a Rasa model (Core and",
"NLU model training will be skipped now.\" ) return return",
"fingerprint_comparison.nlu == True: # replace True with list of all",
"stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # normal (not compare) training print_color(\"Training Core model...\", color=bcolors.OKBLUE)",
"to train the model. output_path: Output path. force_training: If `True`",
"train_path, output_path, force_training, fixed_model_name, persist_nlu_training_data, additional_arguments, ) async def handle_domain_if_not_exists(",
"with the model. Returns: If `train_path` is given it returns",
"import os import tempfile from contextlib import ExitStack from typing",
"additional_arguments: Optional[Dict] = None, loop: Optional[asyncio.AbstractEventLoop] = None, ) ->",
"False, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Trains a",
"data should be persisted with the model. fixed_model_name: Name of",
"check if the provided domain file exists.\" ) return None",
"return await _train_core_with_validated_data( # file_importer, # output=output_path, # fixed_model_name=fixed_model_name, #",
"None, ): if not fingerprint_comparison_result: fingerprint_comparison_result = FingerprintComparisonResult() if fingerprint_comparison_result.should_retrain_core():",
"domain = await file_importer.get_domain() if domain.is_empty(): print_error( \"Core training was",
"ExitStack() as stack: if train_path: # If the train path",
"await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"core-\", )",
"training will be skipped now.\" ) return return await _train_nlu_with_validated_data(",
"to the config file for Core. stories: Path to the",
"the domain file. config: Path to the config file for",
"async def _train_async_internal( file_importer: TrainingDataImporter, train_path: Text, output_path: Text, force_training:",
"# ) # return # if nlu_data.is_empty(): # print_warning(\"No NLU",
"not force_training: fingerprint_comparison = model.should_retrain( new_fingerprint, old_model, train_path ) #",
"return loop.run_until_complete( train_core_async( domain=domain, config=config, stories=stories, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments,",
"force_training: If `True` retrain model even if data has not",
"Args: domain: Path to the domain file. config: Path to",
"persisted with the model. fixed_model_name: Name of model to be",
"Core training since domain or stories are empty.\", color=bcolors.OKBLUE) for",
"output_directory=output_path, train_path=train_path, fixed_model_name=fixed_model_name, ) print_success( \"Nothing changed. You can use",
"file_importer: TrainingDataImporter, output_path: Text, train_path: Text, fingerprint_comparison_result: Optional[FingerprintComparisonResult] = None,",
"Text, output: Text, train_path: Optional[Text] = None, fixed_model_name: Optional[Text] =",
"except RuntimeError: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) return loop.run_until_complete( train_async( domain=domain,",
"did not change. \" \"Only the templates section has been",
"from rasa_addons.importers import BotfrontFileImporter file_importer = BotfrontFileImporter(config, domain, training_files) #",
"_train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod config = await file_importer.get_nlu_config(retrain_nlu)",
"with ExitStack() as stack: train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod",
"path. force_training: If `True` retrain model even if data has",
"print_warning(\"No NLU data present. Just a Rasa Core model will",
") # return # if nlu_data.is_empty(): # print_warning(\"No NLU data",
"output=output_path, fixed_model_name=fixed_model_name ) print_warning( \"Core training was skipped because no",
") -> Optional[Text]: \"\"\"Trains a Rasa model (Core and NLU).",
"data should be persisted with the model. Returns: If `train_path`",
"file_importer = TrainingDataImporter.load_from_config( # config, domain, training_files # ) with",
"stories.is_empty() and nlu_data.is_empty(): # print_error( # \"No training data given.",
"path. train_path: If `None` the model will be trained in",
"additional_arguments: Additional training parameters. Returns: If `train_path` is given it",
"from rasa.utils.common import TempDirectoryPath from rasa.cli.utils import ( print_success, print_warning,",
"additional_arguments: Additional training parameters. Returns: Path of the trained model",
"return loop.run_until_complete( _train_nlu_async( config, nlu_data, output, train_path, fixed_model_name, persist_nlu_training_data, )",
"# \"No training data given. Please provide stories and NLU",
"\"\"\"Train NLU with validated training and config data.\"\"\" import rasa.nlu.train",
"False, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False, additional_arguments:",
"file_importer, # output=output_path, # fixed_model_name=fixed_model_name, # additional_arguments=additional_arguments, # ) new_fingerprint",
"file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, retrain_nlu=fingerprint_comparison_result.nlu, persist_nlu_training_data=persist_nlu_training_data, ) else: print_color( \"NLU",
"use the old model stored at '{}'.\" \"\".format(os.path.abspath(old_model)) ) return",
"even if data has not changed. fixed_model_name: Name of model",
"archive. \"\"\" stories, nlu_data = await asyncio.gather( file_importer.get_stories(), file_importer.get_nlu_data() )",
"= train_path else: # Otherwise, create a temp train path",
"import ExitStack from typing import Text, Optional, List, Union, Dict",
"= None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False,",
"and NLU. output_path: Output path. force_training: If `True` retrain model",
"mod > if fingerprint_comparison.nlu == True: # replace True with",
"rasa.core.domain import Domain from rasa.utils.common import TempDirectoryPath from rasa.cli.utils import",
"print_color(\"Training Core model...\", color=bcolors.OKBLUE) domain, config = await asyncio.gather( file_importer.get_domain(),",
"fixed_model_name: Optional[Text], persist_nlu_training_data: bool, additional_arguments: Optional[Dict], ) -> Optional[Text]: \"\"\"Trains",
"stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod config = await file_importer.get_nlu_config(retrain_nlu) for lang",
"mod from rasa_addons.importers import BotfrontFileImporter file_importer = BotfrontFileImporter(config, domain, training_files)",
"was created.\" \"Please specify a valid domain using '--domain' argument",
"-> Optional[Text]: \"\"\"Trains a Rasa model (Core and NLU). Args:",
"= False, retrain_nlu: Union[bool, List[Text]] = True ) -> Optional[Text]:",
"False, additional_arguments: Optional[Dict] = None, loop: Optional[asyncio.AbstractEventLoop] = None, )",
"# \"order to train a Rasa model using the '--data'",
"temporary directory, otherwise in the provided directory. fixed_model_name: Name of",
"def train_core_async( domain: Union[Domain, Text], config: Text, stories: Text, output:",
"output_path, force_training, fixed_model_name, persist_nlu_training_data, additional_arguments, ) async def handle_domain_if_not_exists( file_importer:",
"Text = DEFAULT_MODELS_PATH, force_training: bool = False, fixed_model_name: Optional[Text] =",
"= DEFAULT_MODELS_PATH, force_training: bool = False, fixed_model_name: Optional[Text] = None,",
"import config as cfg_loader if train_path: # If the train",
"await model.model_fingerprint(file_importer) old_model = model.get_latest_model(output_path) fingerprint_comparison = FingerprintComparisonResult(force_training=force_training) if not",
"parameters. Returns: Path of the trained model archive. \"\"\" stories,",
"config=config, stories=stories, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) ) async def",
"= model.get_latest_model(output_path) fingerprint_comparison = FingerprintComparisonResult(force_training=force_training) if not force_training: fingerprint_comparison =",
"/bf mod return await _train_async_internal( file_importer, train_path, output_path, force_training, fixed_model_name,",
"persist_nlu_training_data=persist_nlu_training_data, ) else: print_color( \"NLU data/configuration did not change. No",
"file was found. \" \"Please specify a valid domain using",
"file_importer.get_nlu_config(retrain_nlu) for lang in config: if config[lang]: print_color(\"Start training {}",
"Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Train Core with validated",
"not core_untrainable fingerprint_comparison.nlu = [l for l in fingerprint_comparison.nlu if",
"change. No need to retrain NLU model.\", color=bcolors.OKBLUE, ) def",
"return await _train_nlu_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, ) async",
") print_success( \"Nothing changed. You can use the old model",
"retrain_nlu: Union[bool, List[Text]] = True ) -> Optional[Text]: \"\"\"Train NLU",
"\"\"\" loop = asyncio.get_event_loop() return loop.run_until_complete( _train_nlu_async( config, nlu_data, output,",
"because no valid domain file was found. \" \"Please specify",
"NLU model. Args: config: Path to the config file for",
"None, ) -> Optional[Text]: if loop is None: try: loop",
"not changed. persist_nlu_training_data: `True` if the NLU training data should",
"in nlu_untrainable] if core_untrainable: print_color(\"Skipping Core training since domain or",
"config: Path to the config file for NLU. nlu_data: Path",
"additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Trains a Rasa",
"Text, train_path: Optional[Text] = None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data:",
"None, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: loop =",
"stories=stories, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) ) async def train_core_async(",
"# ) with ExitStack() as stack: train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) #",
"print_color(\"Start training {} NLU model ...\".format(lang), color=bcolors.OKBLUE) _, models[lang], _",
"if the provided domain file exists.\" ) return None if",
"print_error( \"No stories given. Please provide stories in order to",
"bool = False, retrain_nlu: Union[bool, List[Text]] = True ) ->",
"domain file. config: Path to the config file for Core.",
"if not nlu_data: print_error( \"No NLU data given. Please provide",
"config: Text, training_files: Union[Text, List[Text]], output: Text = DEFAULT_MODELS_PATH, force_training:",
"training_files: Optional[Union[Text, List[Text]]], output_path: Text = DEFAULT_MODELS_PATH, force_training: bool =",
") with ExitStack() as stack: train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf",
"def _train_async_internal( file_importer: TrainingDataImporter, train_path: Text, output_path: Text, force_training: bool,",
"if fingerprint_comparison.nlu == True: # replace True with list of",
"changed. You can use the old model stored at '{}'.\"",
"to the config file for NLU. nlu_data: Path to the",
"persist_nlu_training_data: bool = False, retrain_nlu: Union[bool, List[Text]] = True )",
"= BotfrontFileImporter(config, domain, training_files) # domain = await file_importer.get_domain() #",
"_train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # normal (not compare) training print_color(\"Training Core",
"bool = False, ) -> Optional[Text]: \"\"\"Trains an NLU model.",
"not change. No need to retrain NLU model.\", color=bcolors.OKBLUE, )",
"need to retrain NLU model.\", color=bcolors.OKBLUE, ) def train_core( domain:",
"nlu_data: Path to the NLU training data. output: Output path.",
"provide stories in order to \" \"train a Rasa Core",
"it. \" \"Please verify the data format. \" \"The NLU",
"train_path) else: print_color( \"Core stories/configuration did not change. No need",
"model.\", color=bcolors.OKBLUE, ) def train_core( domain: Union[Domain, Text], config: Text,",
"= None, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Train",
"Name of the model to be stored. persist_nlu_training_data: `True` if",
"config: Dict[Text, Text], training_files: Optional[Union[Text, List[Text]]], output_path: Text = DEFAULT_MODELS_PATH,",
"train_nlu( config: Text, nlu_data: Text, output: Text, train_path: Optional[Text] =",
"None, additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Trains a",
"\"Only the templates section has been changed. A new model",
"Only Core was trained. new_fingerprint = await model.model_fingerprint(file_importer) return model.package_model(",
"in a temporary directory, otherwise in the provided directory. fixed_model_name:",
"None, ) -> Optional[Text]: loop = asyncio.get_event_loop() return loop.run_until_complete( train_core_async(",
"trained new_fingerprint = await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path,",
"NLU). Args: domain: Path to the domain file. config: Dict",
"fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False, ) ->",
"the training data. train_path: Directory in which to train the",
"(Core and NLU). Args: domain: Path to the domain file.",
"training_files # ) with ExitStack() as stack: train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp()))",
"fixed_model_name, persist_nlu_training_data, ) ) async def _train_nlu_async( config: Text, nlu_data:",
"output_path: Text, force_training: bool, fixed_model_name: Optional[Text], persist_nlu_training_data: bool, additional_arguments: Optional[Dict],",
"Core model using the '--stories' argument.\" ) return return await",
"print_color(\"No NLU data found for language <{}>, skipping training...\".format(lang), color=bcolors.OKBLUE)",
"if fingerprint_comparison.is_training_required(): await _do_training( file_importer, output_path=output_path, train_path=train_path, fingerprint_comparison_result=fingerprint_comparison, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data,",
"None, ) -> Optional[Text]: \"\"\"Trains a Core model. Args: domain:",
"was found. \" \"Please specify a valid domain using '--domain'",
"if nlu_data.is_empty(): # print_warning(\"No NLU data present. Just a Rasa",
"file. config: Dict of paths to the config for Core",
"Text, train_path: Text, fingerprint_comparison_result: Optional[FingerprintComparisonResult] = None, fixed_model_name: Optional[Text] =",
"Core and NLU. Keys are language codes training_files: Paths to",
"Name of model to be stored. persist_nlu_training_data: `True` if the",
"domain file exists.\" ) return nlu_model_only async def _train_async_internal( file_importer:",
"color=bcolors.OKBLUE, ) await model.update_model_with_new_domain(file_importer, train_path) else: print_color( \"Core stories/configuration did",
"print_warning, print_error, bcolors, print_color, ) from rasa.constants import DEFAULT_MODELS_PATH, DEFAULT_CORE_SUBDIRECTORY_NAME",
"Text], config: Text, stories: Text, output: Text, train_path: Optional[Text] =",
"Optional[Text] = None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool =",
"print_warning( \"Core training was skipped because no valid domain file",
"valid NLU data in it. \" \"Please verify the data",
"Optional[Text] = None, fixed_model_name: Optional[Text] = None, additional_arguments: Optional[Dict] =",
"await _do_training( file_importer, output_path=output_path, train_path=train_path, fingerprint_comparison_result=fingerprint_comparison, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, )",
"file_importer = TrainingDataImporter.load_core_importer_from_config( config, domain, [stories] ) domain = await",
") return return await _train_core_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments,",
"def _train_nlu_with_validated_data( file_importer: TrainingDataImporter, output: Text, train_path: Optional[Text] = None,",
"Optional[Text]: \"\"\"Trains an NLU model. Args: config: Path to the",
"model to be stored. additional_arguments: Additional training parameters. Returns: Path",
"only hence the training files still have to be selected",
"persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) ) async def train_async( domain: Union[Domain, Text],",
"using the '--nlu' argument.\" ) return # training NLU only",
"config: Dict of paths to the config for Core and",
"model.model_fingerprint(file_importer) old_model = model.get_latest_model(output_path) fingerprint_comparison = FingerprintComparisonResult(force_training=force_training) if not force_training:",
"file_importer, train_path, output_path, force_training, fixed_model_name, persist_nlu_training_data, additional_arguments, ) async def",
") await model.update_model_with_new_domain(file_importer, train_path) else: print_color( \"Core stories/configuration did not",
"train_path ) # bf mod > if fingerprint_comparison.nlu == True:",
"file_importer.get_domain() # if domain.is_empty(): # return await handle_domain_if_not_exists( # file_importer,",
"await _train_nlu_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, ) async def",
"fingerprint_comparison.core = fingerprint_comparison.core and not core_untrainable fingerprint_comparison.nlu = [l for",
"the model archive, otherwise the path to the directory with",
"additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: \"\"\"Train Core with",
"train_path: Optional[Text] = None, fixed_model_name: Optional[Text] = None, additional_arguments: Optional[Dict]",
"Union[Domain, Text], config: Dict[Text, Text], training_files: Optional[Union[Text, List[Text]]], output_path: Text",
"print_error( \"Core training was skipped because no valid domain file",
"training...\".format(lang), color=bcolors.OKBLUE) # /bf mod print_color(\"NLU model training completed.\", color=bcolors.OKBLUE)",
"[stories] ) domain = await file_importer.get_domain() if domain.is_empty(): print_error( \"Core",
"config[lang]: print_color(\"Start training {} NLU model ...\".format(lang), color=bcolors.OKBLUE) _, models[lang],",
"_do_training( file_importer: TrainingDataImporter, output_path: Text, train_path: Text, fingerprint_comparison_result: Optional[FingerprintComparisonResult] =",
"model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name, model_prefix=\"core-\", ) return _train_path def",
"if loop is None: try: loop = asyncio.get_event_loop() except RuntimeError:",
"import tempfile from contextlib import ExitStack from typing import Text,",
"rasa.nlu.train with ExitStack() as stack: models = {} from rasa.nlu",
"return return await _train_nlu_with_validated_data( file_importer, output=output, train_path=train_path, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, )",
"be trained in a temporary directory, otherwise in the provided",
"Args: config: Path to the config file for NLU. nlu_data:",
"file_importer: TrainingDataImporter, output: Text, train_path: Optional[Text] = None, fixed_model_name: Optional[Text]",
"TrainingDataImporter.load_core_importer_from_config( config, domain, [stories] ) domain = await file_importer.get_domain() if",
"Path to the Core training data. output: Output path. train_path:",
"file_importer.get_domain(), file_importer.get_config() ) await rasa.core.train( domain_file=domain, training_resource=file_importer, output_path=os.path.join(_train_path, DEFAULT_CORE_SUBDIRECTORY_NAME), policy_config=config,",
"color=bcolors.OKBLUE) domain, config = await asyncio.gather( file_importer.get_domain(), file_importer.get_config() ) await",
"else: print_color( \"Core stories/configuration did not change. No need to",
"train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) ) async def train_core_async( domain: Union[Domain,",
"and NLU. Keys are language codes training_files: Paths to the",
"Rasa NLU model using the '--nlu' argument.\" ) return #",
"print_error, bcolors, print_color, ) from rasa.constants import DEFAULT_MODELS_PATH, DEFAULT_CORE_SUBDIRECTORY_NAME def",
"Path of the trained model archive. \"\"\" stories, nlu_data =",
"data for language <{}> didn't change, skipping training...\".format(lang), color=bcolors.OKBLUE) #",
"None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool = False, )",
"should be persisted with the model. Returns: If `train_path` is",
"from rasa.constants import DEFAULT_MODELS_PATH, DEFAULT_CORE_SUBDIRECTORY_NAME def train( domain: Text, config:",
"config data.\"\"\" import rasa.nlu.train with ExitStack() as stack: models =",
"provided, do nothing on exit. _train_path = train_path else: #",
"= TrainingDataImporter.load_core_importer_from_config( config, domain, [stories] ) domain = await file_importer.get_domain()",
"order to \" \"train a Rasa Core model using the",
"# additional_arguments=additional_arguments, # ) new_fingerprint = await model.model_fingerprint(file_importer) old_model =",
"asyncio.set_event_loop(loop) return loop.run_until_complete( train_async( domain=domain, config=config, training_files=training_files, output_path=output, force_training=force_training, fixed_model_name=fixed_model_name,",
"file for Core. stories: Path to the Core training data.",
"domain, config = await asyncio.gather( file_importer.get_domain(), file_importer.get_config() ) await rasa.core.train(",
"to the model archive, otherwise the path to the directory",
"NLU data in it. \" \"Please verify the data format.",
") ) async def train_async( domain: Union[Domain, Text], config: Dict[Text,",
"await file_importer.get_domain() if domain.is_empty(): print_error( \"Core training was skipped because",
"NLU only hence the training files still have to be",
"async def train_async( domain: Union[Domain, Text], config: Dict[Text, Text], training_files:",
") # bf mod > if fingerprint_comparison.nlu == True: #",
"train_path: Directory in which to train the model. output_path: Output",
"files still have to be selected file_importer = TrainingDataImporter.load_nlu_importer_from_config( config,",
"asyncio.new_event_loop() asyncio.set_event_loop(loop) return loop.run_until_complete( train_async( domain=domain, config=config, training_files=training_files, output_path=output, force_training=force_training,",
"training_files: Union[Text, List[Text]], output: Text = DEFAULT_MODELS_PATH, force_training: bool =",
"-> Optional[Text]: if loop is None: try: loop = asyncio.get_event_loop()",
"Rasa model (Core and NLU). Args: domain: Path to the",
"Path of the trained model archive. \"\"\" # file_importer =",
"return await _train_async_internal( file_importer, train_path, output_path, force_training, fixed_model_name, persist_nlu_training_data, additional_arguments,",
"the config file for NLU. nlu_data: Path to the NLU",
"new_fingerprint = await model.model_fingerprint(file_importer) return model.package_model( fingerprint=new_fingerprint, output_directory=output, train_path=_train_path, fixed_model_name=fixed_model_name,",
"_do_training( file_importer, output_path=output_path, train_path=train_path, fingerprint_comparison_result=fingerprint_comparison, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) return",
"Optional[FingerprintComparisonResult] = None, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool =",
") from rasa.constants import DEFAULT_MODELS_PATH, DEFAULT_CORE_SUBDIRECTORY_NAME def train( domain: Text,",
"was skipped because no valid domain file was found. Only",
"train path was provided, do nothing on exit. _train_path =",
"all langs fingerprint_comparison.nlu = list(new_fingerprint.get(\"nlu-config\", {}).keys()) domain = await file_importer.get_domain()",
"not in nlu_untrainable] if core_untrainable: print_color(\"Skipping Core training since domain",
"await file_importer.get_domain() # if domain.is_empty(): # return await handle_domain_if_not_exists( #",
"`train_path` is given it returns the path to the model",
"return # if nlu_data.is_empty(): # print_warning(\"No NLU data present. Just",
"await file_importer.get_stories(): print_error( \"No stories given. Please provide stories in",
"Optional[Text] = None, persist_nlu_training_data: bool = False, additional_arguments: Optional[Dict] =",
"up on exit. _train_path = stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # normal (not compare)",
"<{}> didn't change, skipping training...\".format(lang), color=bcolors.OKBLUE) # /bf mod print_color(\"NLU",
"nlu-model was created.\" \"Please specify a valid domain using '--domain'",
"force_training=force_training, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) ) async def train_async( domain:",
"bool = False, additional_arguments: Optional[Dict] = None, loop: Optional[asyncio.AbstractEventLoop] =",
"file_importer: `TrainingDataImporter` which supplies the training data. train_path: Directory in",
"training...\".format(lang), color=bcolors.OKBLUE) # </ bf mod if fingerprint_comparison.is_training_required(): await _do_training(",
"data. output: Output path. train_path: If `None` the model will",
") -> Optional[Text]: \"\"\"Trains an NLU model. Args: config: Path",
"if train_path is None: # Only Core was trained. new_fingerprint",
"print_color( \"Core stories/configuration did not change. \" \"Only the templates",
"def train( domain: Text, config: Text, training_files: Union[Text, List[Text]], output:",
"additional_arguments: Optional[Dict] = None, ) -> Optional[Text]: loop = asyncio.get_event_loop()",
"fixed_model_name=fixed_model_name, retrain_nlu=fingerprint_comparison_result.nlu, persist_nlu_training_data=persist_nlu_training_data, ) else: print_color( \"NLU data/configuration did not",
"specify a valid domain using '--domain' argument or check if",
"returns the path to the model archive, otherwise the path",
"if data has not changed. persist_nlu_training_data: `True` if the NLU",
"return model.package_model( fingerprint=new_fingerprint, output_directory=output_path, train_path=train_path, fixed_model_name=fixed_model_name, ) print_success( \"Nothing changed.",
"d in nlu_data.items() if d.is_empty()] fingerprint_comparison.core = fingerprint_comparison.core and not",
"-> Optional[Text]: \"\"\"Train Core with validated training and config data.\"\"\"",
"\"\"\"Trains a Rasa model (Core and NLU). Args: domain: Path",
") ) async def train_core_async( domain: Union[Domain, Text], config: Text,",
"will be skipped now.\" ) return return await _train_nlu_with_validated_data( file_importer,",
"training_datas.is_empty(): print_error( f\"Path '{nlu_data}' doesn't contain valid NLU data in",
"core_untrainable fingerprint_comparison.nlu = [l for l in fingerprint_comparison.nlu if l",
"force_training: bool = False, fixed_model_name: Optional[Text] = None, persist_nlu_training_data: bool",
") print_color(\"Core model training completed.\", color=bcolors.OKBLUE) if train_path is None:",
"NLU data given. Please provide NLU data in order to",
"at '{}'.\" \"\".format(os.path.abspath(old_model)) ) return old_model async def _do_training( file_importer:",
"otherwise the path to the directory with the trained model",
"contextlib import ExitStack from typing import Text, Optional, List, Union,",
"\"NLU data/configuration did not change. No need to retrain NLU",
"domain: Path to the domain file. config: Dict of paths",
"model. Args: config: Path to the config file for NLU.",
"file_importer, output_path=output_path, train_path=train_path, fingerprint_comparison_result=fingerprint_comparison, fixed_model_name=fixed_model_name, persist_nlu_training_data=persist_nlu_training_data, additional_arguments=additional_arguments, ) return model.package_model(",
"output_path: Text, train_path: Text, fingerprint_comparison_result: Optional[FingerprintComparisonResult] = None, fixed_model_name: Optional[Text]",
"train_core_async( domain: Union[Domain, Text], config: Text, stories: Text, output: Text,",
"None: try: loop = asyncio.get_event_loop() except RuntimeError: loop = asyncio.new_event_loop()",
"stored at '{}'.\" \"\".format(os.path.abspath(old_model)) ) return old_model async def _do_training(",
"change. No need to retrain Core model.\", color=bcolors.OKBLUE, ) if",
"with ExitStack() as stack: models = {} from rasa.nlu import",
"to the training data for Core and NLU. output_path: Output",
"= stack.enter_context(TempDirectoryPath(tempfile.mkdtemp())) # bf mod config = await file_importer.get_nlu_config(retrain_nlu) for",
") ) async def _train_nlu_async( config: Text, nlu_data: Text, output:",
"data. train_path: Directory in which to train the model. output_path:",
"None, loop: Optional[asyncio.AbstractEventLoop] = None, ) -> Optional[Text]: if loop",
"NLU. Keys are language codes training_files: Paths to the training",
"file_importer.get_nlu_data() ) # if stories.is_empty() and nlu_data.is_empty(): # print_error( #",
"loop.run_until_complete( train_core_async( domain=domain, config=config, stories=stories, output=output, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, )",
"color=bcolors.OKBLUE) if train_path is None: # Only Core was trained.",
"= [l for l, d in nlu_data.items() if d.is_empty()] fingerprint_comparison.core",
"file_importer, output=output_path, train_path=train_path, fixed_model_name=fixed_model_name, additional_arguments=additional_arguments, ) elif fingerprint_comparison_result.should_retrain_nlg(): print_color( \"Core",
") async def train_async( domain: Union[Domain, Text], config: Dict[Text, Text],",
"# return await _train_core_with_validated_data( # file_importer, # output=output_path, # fixed_model_name=fixed_model_name,",
"output_path, fixed_model_name ): nlu_model_only = await _train_nlu_with_validated_data( file_importer, output=output_path, fixed_model_name=fixed_model_name",
"'{nlu_data}' doesn't contain valid NLU data in it. \" \"Please"
] |
[
"if prices[j]<=prices[i]: res.append(prices[i]-prices[j]) break if j==len(prices)-1: res.append(prices[i]) res.append(prices[-1]) return res",
"in range(len(prices)): for j in range(i+1,len(prices)): if prices[j]<=prices[i]: res.append(prices[i]-prices[j]) break",
"List[int]: res = [] for i in range(len(prices)): for j",
"in range(i+1,len(prices)): if prices[j]<=prices[i]: res.append(prices[i]-prices[j]) break if j==len(prices)-1: res.append(prices[i]) res.append(prices[-1])",
"j in range(i+1,len(prices)): if prices[j]<=prices[i]: res.append(prices[i]-prices[j]) break if j==len(prices)-1: res.append(prices[i])",
"-> List[int]: res = [] for i in range(len(prices)): for",
"Solution: def finalPrices(self, prices: List[int]) -> List[int]: res = []",
"class Solution: def finalPrices(self, prices: List[int]) -> List[int]: res =",
"[] for i in range(len(prices)): for j in range(i+1,len(prices)): if",
"prices: List[int]) -> List[int]: res = [] for i in",
"range(len(prices)): for j in range(i+1,len(prices)): if prices[j]<=prices[i]: res.append(prices[i]-prices[j]) break if",
"List[int]) -> List[int]: res = [] for i in range(len(prices)):",
"range(i+1,len(prices)): if prices[j]<=prices[i]: res.append(prices[i]-prices[j]) break if j==len(prices)-1: res.append(prices[i]) res.append(prices[-1]) return",
"<gh_stars>1-10 class Solution: def finalPrices(self, prices: List[int]) -> List[int]: res",
"finalPrices(self, prices: List[int]) -> List[int]: res = [] for i",
"def finalPrices(self, prices: List[int]) -> List[int]: res = [] for",
"i in range(len(prices)): for j in range(i+1,len(prices)): if prices[j]<=prices[i]: res.append(prices[i]-prices[j])",
"for i in range(len(prices)): for j in range(i+1,len(prices)): if prices[j]<=prices[i]:",
"res = [] for i in range(len(prices)): for j in",
"= [] for i in range(len(prices)): for j in range(i+1,len(prices)):",
"for j in range(i+1,len(prices)): if prices[j]<=prices[i]: res.append(prices[i]-prices[j]) break if j==len(prices)-1:"
] |
["self._context['is_redraw'] = False self._is_multi = len(sources) > 1 if not","self._vim.command('v(...TRUNCATED)
|
["_stdchannel_redirected(stdchannel, dest_filename, mode=\"w\"): \"\"\" A context manager to tempora(...TRUNCATED)
|
["\"grey\" app_email = \"<EMAIL>\" app_license = \"MIT\" # Includes in",": \"public/js/doctype.js\"}(...TRUNCATED)
|
["= Embedding(self._vocab_size, 64)(question) eb_question = Dropout(0.3)(eb_question) conc = concate(...TRUNCATED)
|
[] |
["activationName self.bn_name = bnName self.first_output = num_planes self.in_planes = self.first_ou(...TRUNCATED)
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 3