slthcore 0.4.6__tar.gz → 0.4.8__tar.gz

{slthcore-0.4.6/slthcore.egg-info → slthcore-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: slthcore
-Version: 0.4.6
+Version: 0.4.8
 Summary: API generator based on yml file
 Home-page: https://github.com/brenokcc
 Author: Breno Silva

{slthcore-0.4.6 → slthcore-0.4.8}/setup.py

@@ -1,11 +1,10 @@
-import os
 from setuptools import find_packages, setup
 
 install_requires = []
 
 setup(
     name='slthcore',
-    version='0.4.6',
+    version='0.4.8',
     packages=find_packages(),
     install_requires=install_requires,
     include_package_data=True,

{slthcore-0.4.6 → slthcore-0.4.8}/slth/__init__.py

@@ -1,6 +1,3 @@
-import re
-import os
-import yaml
 import json
 import warnings
 from pathlib import Path
@@ -15,6 +12,7 @@ import django.db.models.options as options
 from django.db.models.base import ModelBase
 from django.db.models import Model
 from django.core.exceptions import FieldDoesNotExist
+from django.core.exceptions import ObjectDoesNotExist
 from django.utils.autoreload import autoreload_started
 from django.core import serializers
 from django.utils import autoreload
@@ -29,15 +27,6 @@ FILENAME = 'application.yml'
 ENDPOINTS = {}
 PROXIED_MODELS = []
 THREADS = []
-APPLICATON = None
-
-if APPLICATON is None and os.path.exists(FILENAME):
-    with open(FILENAME) as file:
-        content = file.read()
-        for variable in re.findall(r'\$[a-zA-z0-9_]+', content):
-            content = content.replace(variable, os.environ.get(variable[1:], ''))
-    APPLICATON = yaml.safe_load(content).get('application')
-
 
 class JSONEncoder(json.JSONEncoder):
     def default(self, obj):
@@ -185,13 +174,19 @@ def save_decorator(func):
             if obj:
                 for field in self._meta.fields:
                     a = getattr(obj, field.name)
-                    b = getattr(self, field.name)
+                    try:
+                        b = getattr(self, field.name)
+                    except ObjectDoesNotExist:
+                        b = None
                     if a != b:
                         diff[field.verbose_name] = (serialize(a), serialize(b))
         else:
             action = 'add'
             for field in self._meta.fields:
-                b = getattr(self, field.name)
+                try:
+                    b = getattr(self, field.name)
+                except ObjectDoesNotExist:
+                    b = None
                 if b is not None:
                     diff[field.verbose_name] = (None, serialize(b))
         func(self, *args, **kwargs)

slthcore-0.4.8/slth/application.py

@@ -0,0 +1,178 @@
+
+from slth import ENDPOINTS
+from .utils import build_url
+from django.conf import settings
+from django.apps import apps
+
+APPLICATION_CLASS = None
+
+
+class Style():
+    def __init__(self, color="black", background="inherite", border="none"):
+        self.update(color=color, background=background, border=border)
+
+    def update(self, color=None, background=None, border=None):
+        if color:
+            self.color = color
+        if background:
+            self.background = background
+        if border:
+            self.border = border
+
+
+class Theme():
+    def __init__(self):
+        self.primary:Style = Style("#1351b4")
+        self.secondary:Style = Style("#071e41")
+        self.auxiliary:Style = Style("#2670e8")
+        self.highlight:Style = Style("#0c326f")
+
+        self.info:Style = Style("#1351b4", "#d4e5ff")
+        self.success:Style = Style("#1351b4")
+        self.warning:Style = Style("#fff5c2")
+        self.danger:Style = Style("#e52207")
+
+
+class Groups(dict):
+    def add(self, **kwargs):
+        self.update(**kwargs)
+
+class Menu(dict):
+    def add(self, arg):
+        self.update(arg)
+
+    def process(self, request):
+        items = []
+
+        def get_item(k, v):
+            if isinstance(v, dict):
+                icon, label = k.split(":") if ":" in k else (None, k)
+                subitems = []
+                for k1, v1 in v.items():
+                    subitem = get_item(k1, v1)
+                    if subitem:
+                        subitems.append(subitem)
+                if subitems:
+                    return dict(dict(icon=icon, label=label, items=subitems))
+            else:
+                cls = ENDPOINTS.get(v)
+                if cls:
+                    endpoint = cls().instantiate(request, None)
+                    if endpoint.check_permission() and endpoint.contribute("menu"):
+                        icon, label = k.split(":") if ":" in k else (None, k)
+                        url = build_url(request, cls.get_api_url())
+                        return dict(dict(label=label, url=url, icon=icon))
+
+        for k, v in self.items():
+            item = get_item(k, v)
+            if item:
+                items.append(item)
+        
+        return items
+
+class Oauth(list):
+    def add(self, name, client_id, client_secret, redirect_uri, authorize_url, access_token_url, user_data_url, user_logout_url, user_scope, user_create, user_username, user_email):
+        super().append(dict(name=name, client_id=client_id, client_secret=client_secret, redirect_uri=redirect_uri, authorize_url=authorize_url, access_token_url=access_token_url, user_data_url=user_data_url, user_logout_url=user_logout_url, user_scope=user_scope, user_create=user_create, user_username=user_username, user_email=user_email))
+
+    def serialize(self):
+        data = []
+        for provider in self:
+            redirect_uri = "{}{}".format(settings.SITE_URL, provider['redirect_uri'])
+            authorize_url = '{}?response_type=code&client_id={}&redirect_uri={}'.format(
+                provider['authorize_url'], provider['client_id'], redirect_uri
+            )
+            if provider.get('scope'):
+                authorize_url = '{}&scope={}'.format(authorize_url, provider.get('scope'))
+            data.append(dict(label=f'Entrar com {provider["name"]}', url=authorize_url))
+        return data
+
+class List(list):
+
+    def add(self, *names):
+        super().extend(names)
+
+
+class Dashboard():
+    def __init__(self):
+        self.actions:List = List()
+        self.toolbar:List = List()
+        self.top:List = List()
+        self.center:List = List()
+        self.boxes:List = List()
+        self.search:List = List()
+        self.usermenu:List = List()
+        self.adder:List = List()
+        self.tools:List = List()
+        self.settings:List = List()
+        self.index = "dashboard"
+
+
+class ApplicationMetaclass(type):
+    
+    def __new__(mcs, name, bases, attrs):
+        global APPLICATION_CLASS
+        cls = super().__new__(mcs, name, bases, attrs)
+        APPLICATION_CLASS = cls
+        return cls
+
+
+class Application(metaclass=ApplicationMetaclass):
+    
+    def __init__(self):
+        self.lang = "pt-br"
+        self.title = "Sloth"
+        self.subtitle = "Take your time!"
+        self.icon = "/static/images/logo.png"
+        self.logo = "/static/images/logo.png"
+        self.version =  "0.0.1"
+        self.oauth:Oauth = Oauth()
+        self.groups:Groups = Groups()
+        self.menu:Menu = Menu()
+        self.dashboard = Dashboard()
+        self.theme:Theme = Theme()
+
+    def load(self):
+        pass
+
+    def serialize(self, request):
+        icon = build_url(request, self.icon)
+        logo = build_url(request, self.logo)
+        if request.user.is_authenticated:
+            user = request.user.username.split()[0].split("@")[0]
+            profile = apps.get_model("slth", "profile").objects.filter(user=request.user).first()
+            photo = profile and profile.photo and build_url(request, profile.photo.url) or None
+        else:
+            user = profile = photo = None
+        endpoints = {"actions": [], "usermenu": [], "adder": [], "settings": [], "tools": [], "toolbar": []}
+        for entrypoint in endpoints:
+            for endpoint_name in getattr(self.dashboard, entrypoint):
+                cls = ENDPOINTS[endpoint_name]
+                endpoint = cls().instantiate(request, None)
+                if endpoint.check_permission() and endpoint.contribute(entrypoint):
+                    name = endpoint.get_verbose_name()
+                    url = build_url(request, cls.get_api_url())
+                    modal = cls.get_metadata("modal", False)
+                    icon = cls.get_metadata("icon", None)
+                    endpoints[entrypoint].append(dict(name=name, url=url, modal=modal, icon=icon))
+        return dict(
+            type="application",
+            icon=icon,
+            navbar=dict(
+                type="navbar", title=self.title, subtitle=self.subtitle, logo=logo, user=user, **endpoints
+            ),
+            menu=dict(
+                type="menu", items=self.menu.process(request), user=user, image=photo
+            ),
+            footer=dict(
+                type="footer", version=self.version
+            ),
+            oauth=self.oauth.serialize(),
+            sponsors=[]
+        )
+    
+    @staticmethod
+    def get_instance():
+        instance = APPLICATION_CLASS()
+        instance.load()
+        return instance
+

slthcore-0.4.8/slth/cmd/init/boilerplate/backend/api/__init__.py

@@ -0,0 +1,27 @@
+from slth.application import Application
+
+
+class ApiApplication(Application):
+    def __init__(self):
+        super().__init__()
+        self.groups.add(administrador="Administrador", operador="Operador")
+        self.dashboard.usermenu.add(
+            "dev.icons",
+            "user.users",
+            "log.logs",
+            "email.emails",
+            "pushsubscription.pushsubscriptions",
+            "job.jobs",
+            "deletion.deletions",
+            "auth.logout",
+        )
+        self.dashboard.boxes.add("user.users")
+        self.dashboard.actions.add()
+        self.dashboard.toolbar.add()
+        self.dashboard.top.add()
+        self.dashboard.center.add()
+        self.dashboard.search.add()
+        self.dashboard.adder.add()
+        self.dashboard.tools.add()
+        self.dashboard.settings.add()
+        self.menu.add({"Sair": "auth.logout"})

{slthcore-0.4.6 → slthcore-0.4.8}/slth/db/models.py

@@ -36,6 +36,7 @@ class IntegerField(IntegerField):
         field.pick = self.pick
         return field
 
+
 class ForeignKey(ForeignKey):
     def __init__(self, to, on_delete=None, **kwargs):
         self.pick = kwargs.pop('pick', False)

{slthcore-0.4.6 → slthcore-0.4.8}/slth/endpoints/__init__.py

@@ -19,19 +19,16 @@ from django.template.loader import render_to_string
 from ..forms import ModelForm, Form
 from ..serializer import serialize, Serializer
 from ..components import (
-    Application as Application_,
-    Navbar,
-    Menu,
-    Footer,
     Response,
     Boxes,
     TemplateContent,
 )
+from slth.application import Application as ApplicationConfig
 from ..exceptions import JsonResponseException, ReadyResponseException
 from ..utils import build_url, append_url
 from ..models import Profile, Log, Job
 from slth.queryset import QuerySet
-from slth import APPLICATON, ENDPOINTS
+from slth import ENDPOINTS
 from .. import oauth
 from ..threadlocal import tl
 from ..tasks import Task
@@ -511,9 +508,10 @@ class Search(Endpoint):
         key = "_options_"
         options = self.cache.get(key, [])
         term = self.request.GET.get("term")
-        if options is None and APPLICATON["dashboard"]["search"]:
+        application = ApplicationConfig.get_instance()
+        if options is None and application.dashboard.search:
             options = []
-            for name in APPLICATON["dashboard"]["search"]:
+            for name in application.dashboard.search:
                 cls = ENDPOINTS[name]
                 endpoint = cls.instantiate(self.request, self)
                 if endpoint.check_permission():
@@ -537,7 +535,8 @@ class Home(PublicEndpoint):
         verbose_name = ""
 
     def get(self):
-        cls = ENDPOINTS[APPLICATON["index"]]
+        application = ApplicationConfig.get_instance()
+        cls = ENDPOINTS[application.dashboard.index]
         self.redirect(cls.get_api_url())
 
 
@@ -546,10 +545,11 @@ class Dashboard(Endpoint):
         verbose_name = ""
 
     def get(self):
+        application = ApplicationConfig.get_instance()
         serializer = Serializer(request=self.request)
-        if APPLICATON["dashboard"]["boxes"]:
+        if application.dashboard.boxes:
             boxes = Boxes("Acesso Rápido")
-            for name in APPLICATON["dashboard"]["boxes"]:
+            for name in application.dashboard.boxes:
                 cls = ENDPOINTS[name]
                 endpoint = cls().contextualize(self.request)
                 if endpoint.check_permission():
@@ -558,9 +558,9 @@ class Dashboard(Endpoint):
                     url = build_url(self.request, cls.get_api_url())
                     boxes.append(icon, label, url)
             serializer.append("Acesso Rápido", boxes)
-        if APPLICATON["dashboard"]["top"]:
+        if application.dashboard.top:
             group = serializer.group("Top")
-            for name in APPLICATON["dashboard"]["top"]:
+            for name in application.dashboard.top:
                 cls = ENDPOINTS[name]
                 endpoint = cls.instantiate(self.request, self)
                 if endpoint.check_permission():
@@ -568,8 +568,8 @@ class Dashboard(Endpoint):
                         endpoint.get_verbose_name(), cls, wrap=False
                     )
             group.parent()
-        if APPLICATON["dashboard"]["center"]:
-            for name in APPLICATON["dashboard"]["center"]:
+        if application.dashboard.center:
+            for name in application.dashboard.center:
                 cls = ENDPOINTS[name]
                 endpoint = cls.instantiate(self.request, self)
                 if endpoint.check_permission():
@@ -584,79 +584,7 @@ class Dashboard(Endpoint):
 
 class Application(PublicEndpoint):
     def get(self):
-        user = None
-        photo = None
-        navbar = None
-        menu = None
-        icon = build_url(self.request, APPLICATON["logo"])
-        logo = build_url(self.request, APPLICATON["logo"])
-        if self.request.user.is_authenticated:
-            user = self.request.user.username.split()[0].split("@")[0]
-            profile = Profile.objects.filter(user=self.request.user).first()
-            photo = profile and profile.photo and build_url(self.request, profile.photo.url) or None
-
-        navbar = Navbar(
-            title=APPLICATON["title"],
-            subtitle=APPLICATON["subtitle"],
-            logo=logo,
-            user=user,
-            photo=photo,
-            search=False,
-            roles=' | '.join((str(role) for role in self.objects('slth.role').filter(username=self.request.user.username)))
-        )
-        for entrypoint in ["actions", "usermenu", "adder", "settings", "tools", "toolbar"]:
-            if APPLICATON["dashboard"][entrypoint]:
-                for endpoint_name in APPLICATON["dashboard"][entrypoint]:
-                    cls = ENDPOINTS[endpoint_name]
-                    endpoint = cls().instantiate(self.request, self)
-                    if endpoint.check_permission() and endpoint.contribute(entrypoint):
-                        label = endpoint.get_verbose_name()
-                        url = build_url(self.request, cls.get_api_url())
-                        modal = cls.get_metadata("modal", False)
-                        icon = cls.get_metadata("icon", None)
-                        navbar.add_action(entrypoint, label, url, modal, icon=icon)
-        
-        if APPLICATON["menu"]:
-            items = []
-
-            def get_item(k, v):
-                if isinstance(v, dict):
-                    icon, label = k.split(":") if ":" in k else (None, k)
-                    subitems = []
-                    for k1, v1 in v.items():
-                        subitem = get_item(k1, v1)
-                        if subitem:
-                            subitems.append(subitem)
-                    if subitems:
-                        return dict(dict(icon=icon, label=label, items=subitems))
-                else:
-                    cls = ENDPOINTS.get(v)
-                    if cls:
-                        endpoint = cls().instantiate(self.request, self)
-                        if endpoint.check_permission() and endpoint.contribute("menu"):
-                            icon, label = k.split(":") if ":" in k else (None, k)
-                            url = build_url(self.request, cls.get_api_url())
-                            return dict(dict(label=label, url=url, icon=icon))
-
-            for k, v in APPLICATON["menu"].items():
-                item = get_item(k, v)
-                if item:
-                    items.append(item)
-            profile = (
-                Profile.objects.filter(user=self.request.user).first() if user else None
-            )
-            photo_url = (
-                profile.photo.url
-                if profile and profile.photo
-                else "/static/images/user.svg"
-            )
-            menu = Menu(items, user=user, image=build_url(self.request, photo_url))
-
-        footer = Footer(APPLICATON["version"])
-        return Application_(
-            icon=icon, navbar=navbar, menu=menu, footer=footer, oauth=oauth.providers(),
-            sponsors=APPLICATON.get("sponsors", ())
-        )
+        return ApplicationConfig.get_instance().serialize(self.request)
 
 
 class Manifest(PublicEndpoint):
@@ -665,17 +593,18 @@ class Manifest(PublicEndpoint):
         verbose_name = "Manifest"
 
     def get(self):
+        application = ApplicationConfig.get_instance()
         return dict(
             {
-                "name": APPLICATON["title"],
-                "short_name": APPLICATON["title"],
+                "name": application.title,
+                "short_name": application.title,
                 "lang": "pt-BR",
                 "start_url": build_url(self.request, "/app/home/"),
                 "scope": build_url(self.request, "/app/"),
                 "display": "standalone",
                 "icons": [
                     {
-                        "src": build_url(self.request, APPLICATON["icon"]),
+                        "src": build_url(self.request, application.icon),
                         "sizes": "192x192",
                         "type": "image/png",
                     }
@@ -689,5 +618,5 @@ class Manifest(PublicEndpoint):
 
 class About(PublicEndpoint):
     def get(self):
-        return dict(version=APPLICATON["version"])
-
+        application = ApplicationConfig.get_instance()
+        return dict(version=application.version)

{slthcore-0.4.6 → slthcore-0.4.8}/slth/forms.py

@@ -25,11 +25,11 @@ DjangoFileField = FileField
 DjangoImageField = ImageField
 
 MASKS = dict(
-    cpf_cnpj="999.999.999-99|99.999.999/9999-99",
     cpf="999.999.999-99",
     cnpj="99.999.999/9999-99",
     telefone="(99) 99999-9999",
-    cep='99.999-990'
+    cep='99.999-990',
+    cpf_cnpj="999.999.999-99|99.999.999/9999-99",
 )
 
 
@@ -264,7 +264,7 @@ class FormMixin:
                     field.form(endpoint=self._endpoint).to_dict(prefix=f"{name}__n")
                 )
             required = getattr(field, "required2", field.required)
-            label = field.label.title() if field.label else field.label
+            label = field.label.title() if field.label and field.label.islower() else field.label
             data = dict(
                 type="inline",
                 min=field.min,
@@ -384,10 +384,15 @@ class FormMixin:
                         data.update(pick=append_url(choiceurl, f"choices={fname}") if choiceurl else  absolute_url(
                             self.request, f"choices={fname}"
                         ))
+            if ftype == "boolean":
+                data.update(choices=[
+                    {"id": "true", "value": "Sim"}, {"id": "false", "value": "Não"}, {"id": "null", "value": "Não Informado"}
+                ])
 
-        attr_name = f"on_{name}_change"
+        attr_name = f"on_{prefix}__{name}_change" if prefix else f"on_{name}_change"
+        on_change_name = f"{prefix}__{name}" if prefix else name
         if hasattr(self._endpoint, attr_name):
-            data["onchange"] = absolute_url(self.request, f"on_change={name}")
+            data["onchange"] = absolute_url(self.request, f"on_change={on_change_name}")
         if name in self._actions:
             cls = ENDPOINTS[self._actions[name]]
             endpoint = cls.instantiate(self.request, self)
@@ -409,6 +414,7 @@ class FormMixin:
         }
         self.is_valid()
         errors.update(self.errors)
+        inline_forms = []
         for inline_field_name, inline_field in inline_fields.items():
             data[inline_field_name] = []
             for i in range(0, inline_field.max):
@@ -419,12 +425,21 @@ class FormMixin:
                 inline_form_field_name = f"{prefix}__id"
                 if inline_form_field_name in self.data:
                     inline_form_data = {}
-                    pk = self.data.get(inline_form_field_name)
-                    if pk:
-                        pk = int(pk)
+                    inline_form_field_value = self.data.get(inline_form_field_name)
+                    if inline_form_field_value or is_one_to_one:
+                        pk = int(inline_form_field_value or 0)
                         for name in inline_field.form.base_fields:
+                            inline_form_field = inline_field.form.base_fields[name]
                             inline_form_field_name = f"{prefix}__{name}"
-                            inline_form_data[name] = self.data.get(
+                            inline_form_data[name] = self.data.getlist(
+                                inline_form_field_name
+                            ) if (
+                                (
+                                    isinstance(inline_form_field, DjangoMultipleChoiceField)
+                                    or isinstance(inline_form_field, ModelMultipleChoiceField)
+                                )
+                                and not isinstance(inline_form_field, TypedChoiceField)
+                                ) else self.data.get(
                                 inline_form_field_name
                             )
                             if (
@@ -448,18 +463,22 @@ class FormMixin:
                             instance=instance,
                             endpoint=self._endpoint,
                         )
-                        if inline_form.is_valid():
-                            if isinstance(inline_form, DjangoModelForm):
-                                data[inline_field_name].append(inline_form.instance)
-                            else:
-                                data[inline_field_name].append(inline_form.cleaned_data)
+                        if is_one_to_one and not inline_field.required and not inline_form_field_value:
+                            data[inline_field_name] = []
                         else:
-                            errors.update(
-                                {
-                                    f"{prefix}__{name}": error
-                                    for name, error in inline_form.errors.items()
-                                }
-                            )
+                            if inline_form.is_valid():
+                                if isinstance(inline_form, DjangoModelForm):
+                                    data[inline_field_name].append(inline_form.instance)
+                                else:
+                                    data[inline_field_name].append(inline_form.cleaned_data)
+                                inline_forms.append(inline_form)
+                            else:
+                                errors.update(
+                                    {
+                                        f"{prefix}__{name}": error
+                                        for name, error in inline_form.errors.items()
+                                    }
+                                )
         if errors:
             raise JsonResponseException(
                 dict(type="error", text="Por favor, corrija os erros.", errors=errors)
@@ -481,7 +500,8 @@ class FormMixin:
                         fieldname = attr_name.replace('clean_', '')
                         raise JsonResponseException(dict(type="error", text="Por favor, corrija os erros.", errors={fieldname: ''.join(e.messages)}))
             with transaction.atomic():
-                
+                for inline_form in inline_forms:
+                    inline_form.save()
                 if isinstance(self, DjangoModelForm):
                     self.instance.pre_save()
                     for inline_field_name in inline_fields:
@@ -568,6 +588,8 @@ class ModelForm(DjangoModelForm, FormMixin):
         self._method = "POST"
         self._key = self._title.lower()
         self._autosubmit = None
+        self._submit_label = "Enviar"
+        self._submit_icon = "chevron-right"
 
         self.fieldsets = {}
         self.request = endpoint.request
@@ -740,6 +762,7 @@ FIELD_TYPES = {
     "EmailField": "email",
     "DecimalField": "decimal",
     "BooleanField": "boolean",
+    "NullBooleanField": "boolean",
     "DateTimeField": "datetime",
     "DateField": "date",
     "IntegerField": "number",

slthcore-0.4.8/slth/management/commands/api.py

@@ -0,0 +1,67 @@
+import os
+from django.apps import apps
+from django.utils.text import slugify
+from django.core.management.commands.test import Command
+
+TEMPLATE = """from slth import endpoints
+from ..models import *
+
+
+class {plural}(endpoints.ListEndpoint[{model}]):
+    class Meta:
+        verbose_name = '{verbose_name_plural}'
+
+    def get(self):
+        return (
+            super().get()
+            .actions('{lower}.cadastrar', '{lower}.editar', '{lower}.excluir')
+        )
+
+
+class Cadastrar(endpoints.AddEndpoint[{model}]):
+    class Meta:
+        verbose_name = 'Cadastrar {verbose_name}'
+
+    def get(self):
+        return (
+            super().get()
+        )
+    
+
+class Editar(endpoints.EditEndpoint[{model}]):
+    class Meta:
+        verbose_name = 'Editar {verbose_name}'
+
+    def get(self):
+        return (
+            super().get()
+        )
+
+
+class Excluir(endpoints.DeleteEndpoint[{model}]):
+    class Meta:
+        verbose_name = 'Excluir {verbose_name}'
+
+    def get(self):
+        return (
+            super().get()
+        )
+
+"""
+
+class Command(Command):
+    
+    def handle(self, *args, **options):
+        for model in apps.get_models():
+            if model._meta.app_label == "api":
+                content = TEMPLATE.format(
+                    plural = slugify(model._meta.verbose_name_plural).replace('-de-', '-').replace('-', '').title(),
+                    model = model.__name__,
+                    lower = model.__name__.lower(),
+                    verbose_name = model._meta.verbose_name,
+                    verbose_name_plural = model._meta.verbose_name_plural,
+                )
+                file_path = f'api/endpoints/{model.__name__.lower()}.py'
+                if not os.path.exists(file_path):
+                    with open(file_path, 'w') as file:
+                        file.write(content)