slthcore 0.0.4__tar.gz → 0.0.6__tar.gz

{slthcore-0.0.4/slthcore.egg-info → slthcore-0.0.6}/PKG-INFO

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

{slthcore-0.0.4 → slthcore-0.0.6}/setup.py

@@ -5,7 +5,7 @@ install_requires = []
 
 setup(
     name='slthcore',
-    version='0.0.4',
+    version='0.0.6',
     packages=find_packages(),
     install_requires=install_requires,
     include_package_data=True,

{slthcore-0.0.4 → slthcore-0.0.6}/slth/__init__.py

@@ -1,18 +1,23 @@
 import re
 import os
 import yaml
+import json
 import warnings
 from pathlib import Path
+from datetime import datetime
 from django.apps import apps
 from django.db import models
 from .queryset import QuerySet
 from django.db.models import manager
-from .serializer import Serializer
+from .serializer import Serializer, serialize
+from django.db.models.deletion import Collector
 from .factory import FormFactory
 import django.db.models.options as options
 from django.db.models.base import ModelBase
 from django.core.exceptions import FieldDoesNotExist
 from django.utils.autoreload import autoreload_started
+from django.core import serializers
+from .threadlocal import tl
 
 warnings.filterwarnings('ignore', module='urllib3')
 
@@ -89,6 +94,83 @@ class ModelMixin(object):
     
     def formfactory(self) -> FormFactory:
         return FormFactory(self)
+    
+    def pre_save(self):
+        pass
+
+    def post_save(self):
+        pass
+
+    def safe_delete(self, username=None):
+        from .models import Deletion
+        order = []
+        objects = []
+        collector = Collector('default')
+        qs = type(self).objects.filter(pk=self.pk)
+        collector.collect(qs)
+        for instances in collector.data.values():
+            for instance in instances:
+                if instance.__class__.__name__ not in ['Log'] and instance not in objects:
+                    objects.append(instance)
+                    if instance.__class__.__name__ not in order:
+                        order.append(instance.__class__.__name__)
+        for qs in collector.fast_deletes:
+            for instance in qs:
+                if instance.__class__.__name__ not in ['Log'] and instance not in objects:
+                    objects.append(instance)
+                    if instance.__class__.__name__ not in order:
+                        order.append(instance.__class__.__name__)
+        backup  = json.dumps(dict(order=order, objects=serializers.serialize("python", objects)))
+        instance = '{}.{}:{}'.format(self._meta.app_label, self._meta.model_name, self.pk)
+        Deletion.objects.create(username=username, datetime=datetime.now(), instance=instance, backup=backup)
+        return self.delete()
+
+
+def save_decorator(func):
+    
+    def decorate(self, *args, **kwargs):
+        diff = {}
+        if self.pk:
+            action = 'edit'
+            obj = type(self).objects.filter(pk=self.pk).first()
+            if obj:
+                for field in self._meta.fields:
+                    a = getattr(obj, field.name)
+                    b = getattr(self, field.name)
+                    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)
+                if b is not None:
+                    diff[field.verbose_name] = (None, serialize(b))
+        func(self, *args, **kwargs)
+        if diff:
+            model = '{}.{}'.format(self._meta.app_label, self._meta.model_name)
+            log = dict(model=model, pk=self.pk, action=action, diff=diff)
+            context = getattr(tl, 'context', None)
+            if context:
+                context['logs'].append(log)
+
+    return decorate
+
+
+def delete_decorator(func):
+    def decorate(self, *args, **kwargs):
+        diff = {}
+        for field in self._meta.fields:
+            a = getattr(self, field.name)
+            diff[field.verbose_name] = (a, None)
+        log = dict(model='{}.{}'.format(
+            self._meta.app_label, self._meta.model_name), action='delete', diff=diff
+        )
+        context = getattr(tl, 'context', None)
+        if context:
+            context['logs'].append(log)
+        func(self, *args, **kwargs)
+
+    return decorate
 
 
 ___new___ = ModelBase.__new__
@@ -109,6 +191,9 @@ def __new__(mcs, name, bases, attrs, **kwargs):
     cls = ___new___(mcs, name, bases, attrs, **kwargs)
     if cls._meta.proxy_for_model:
         PROXIED_MODELS.append(cls._meta.proxy_for_model)
+    if name == 'Model':
+        cls.save = save_decorator(cls.save)
+        cls.delete = delete_decorator(cls.delete)
     return cls
 
 

slthcore-0.0.6/slth/cmd/configure/__main__.py

@@ -0,0 +1,88 @@
+import os
+import sys
+import pathlib
+from slth.utils import parse_string_template
+from subprocess import Popen, PIPE
+
+
+USAGE = 'USAGE: python -m slth.cmd.configure [nginx|systemctl]'
+
+NGINX = '''server {
+ listen 80;
+ server_name {{ server_name }};
+ {% if ssl %}
+ listen 443 ssl;
+ ssl_certificate /etc/letsencrypt/live/{{ server_name }}/fullchain.pem;
+ ssl_certificate_key /etc/letsencrypt/live/{{ server_name }}/privkey.pem;
+ if ($scheme = http) { return 301 https://$server_name$request_uri; }
+ {% endif %}
+ location / {
+  proxy_pass http://127.0.0.1:{{ port }};
+ }
+}'''
+
+SERVICE_SCRIPT = '''#!/bin/bash
+source .venv/bin/activate
+
+export POSTGRES_HOST=localhost
+export POSTGRES_DB={{ name }}
+
+python manage.py sync
+gunicorn api.wsgi -b 0.0.0.0:8000 -w 3 --log-level info --reload --timeout 3600
+'''
+
+SERVICE_CONTENT = '''[Unit]
+Description={{ server_name }}
+
+[Service]
+User=www-data
+WorkingDirectory={{ dirname }}
+ExecStart=bash service.sh
+Restart=always
+RestartSec=3
+
+[Install]
+WantedBy=multi-user.target
+'''
+
+def execute(command):
+    process = Popen(command.split(), stdout=PIPE, stderr=PIPE)
+    stdout, stderr = process.communicate()
+    #print(stdout, stderr)
+
+def print_content(file_path, content):
+    print()
+    print(file_path)
+    print('--------------------------')
+    print(content)
+    print('--------------------------')
+
+
+dirname = pathlib.Path().resolve()
+server_name = input('DOMAIN: ')
+name = server_name.split('.')[0]
+
+execute('createdb -U postgres {};'.format(name))
+
+ssl = input('SSL [y|N]: ').lower() == 'y'
+port = input('PORT [8000]: ') or '8000'
+nginx_file_path = f'/etc/nginx/conf.d/{server_name}.conf'
+nginx_file_content = parse_string_template(NGINX, server_name=server_name, ssl=ssl, port=port)
+print_content(nginx_file_path, nginx_file_content)
+
+service_script_path = os.path.join(dirname, 'service.sh')
+service_script_content = parse_string_template(SERVICE_SCRIPT, name=name)
+service_file_content = parse_string_template(SERVICE_CONTENT, server_name=server_name, dirname=dirname)
+service_file_path = f'/etc/systemd/system/{server_name}.service'
+print_content(service_script_path, service_script_content)
+print_content(service_file_path, service_file_content)
+save = input('SAVE [y|N]: ').lower() == 'y'
+if save:
+    with open(nginx_file_path, 'w') as file:
+        file.write(nginx_file_content)
+    with open(service_script_path, 'w') as file:
+        file.write(service_script_content)
+    with open(service_file_path, 'w') as file:
+        file.write(service_file_content)
+
+    execute('systemctl daemon-reload')

{slthcore-0.0.4 → slthcore-0.0.6}/slth/components.py

@@ -289,15 +289,17 @@ class Scheduler(dict):
     def __init__(
         self,
         start_time=7,
-        end_time=20,
+        end_time=23,
         chucks=2,
         start_day=None,
         days=14,
         single_selection=False,
         input_name="schedule",
         readonly=False,
+        title=None
     ):
         self["type"] = "scheduler"
+        self["title"] = title
         self["single_selection"] = single_selection
         self["input_name"] = input_name
         self["readonly"] = readonly

slthcore-0.0.6/slth/db/generic.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+import datetime
+import json
+from decimal import Decimal
+
+from django.apps import apps
+from django.db.models import *
+from django.db.models.query_utils import DeferredAttribute
+
+
+class GenericModelWrapper(object):
+    def __init__(self, obj):
+        self._wrapped_obj = obj
+
+    def __getattr__(self, attr):
+        if attr == 'prepare_database_save':
+            raise AttributeError()
+        return getattr(self._wrapped_obj, attr)
+
+    def __setattr__(self, attr, value):
+        if attr == '_wrapped_obj':
+            super().__setattr__(attr, value)
+        elif self._wrapped_obj is not None:
+            self._wrapped_obj.__setattr__(attr, value._wrapped_obj)
+
+    def __str__(self):
+        return self._wrapped_obj.__str__()
+
+    def __repr__(self):
+        return self._wrapped_obj.__repr__()
+
+
+class GenericValue(object):
+    def __init__(self, value):
+        self.value = value
+
+    def get_value(self):
+        if isinstance(self.value, str) and '::' in self.value:
+            value_type, value = self.value.split('::')
+            if '.' in value_type:
+                self.value = apps.get_model(value_type).objects.get(pk=value)
+            elif value_type == 'str':
+                self.value = value
+            elif value_type == 'int':
+                self.value = int(value)
+            elif value_type == 'Decimal':
+                self.value = Decimal(value)
+            elif value_type in ('date', 'datetime'):
+                self.value = datetime.datetime.strptime(value[0:10], '%Y-%m-%d')
+            elif value_type == 'float':
+                self.value = float(value)
+            elif value_type == 'bool':
+                self.value = value == 'True'
+            elif value_type == 'list':
+                self.value = json.loads(value)
+        return self.value
+
+    def dumps(self):
+        value = self.value
+        if value is not None:
+            if isinstance(value, Model):
+                value = GenericModelWrapper(value)
+            if isinstance(value, GenericModelWrapper):
+                return '{}.{}::{}'.format(
+                    value._meta.app_label, value._meta.model_name, value.pk
+                )
+            if hasattr(value, 'model'):
+                value = list(value.values_list('pk', flat=True))
+            if isinstance(value, list):
+                value = json.dumps(value)
+            return '{}::{}'.format(type(value).__name__, value)
+        return None
+
+
+class GenericFieldDescriptor(DeferredAttribute):
+    def __get__(self, instance, cls=None):
+        obj = super().__get__(instance, cls=cls)
+        if isinstance(obj.value, Model):
+            return GenericModelWrapper(obj.value)
+        return obj.get_value()
+
+    def __set__(self, instance, value):
+        instance.__dict__[self.field.attname] = GenericValue(value)
+
+
+class GenericField(CharField):
+    descriptor_class = GenericFieldDescriptor
+
+    def __init__(self, *args, max_length=255, null=True, **kwargs):
+        super().__init__(*args, max_length=max_length, null=null, **kwargs)
+
+    def get_prep_value(self, value):
+        if value is not None:
+            if isinstance(value, GenericValue):
+                value = value.dumps()
+            else:
+                value = GenericValue(value).dumps()
+        return value

{slthcore-0.0.4 → slthcore-0.0.6}/slth/db/models.py

@@ -2,27 +2,34 @@ from uuid import uuid1
 from django.db.models import Model as DjangoModel
 from django.db.models import *
 from django.utils.translation import gettext_lazy as _
+from . import generic
 from .. import ModelMixin
 
+GenericField = generic.GenericField
+
 class CharField(CharField):
     def __init__(self, *args, **kwargs):
         self.mask = kwargs.pop('mask', None)
+        self.pick = kwargs.pop('pick', False)
         kwargs.setdefault('max_length', 255)
         super().__init__(*args, **kwargs)
 
     def formfield(self, *args, **kwargs):
         field = super().formfield(*args, **kwargs)
         field.mask = self.mask
+        field.pick = self.pick
         return field
     
 class IntegerField(IntegerField):
     def __init__(self, *args, **kwargs):
         self.mask = kwargs.pop('mask', None)
+        self.pick = kwargs.pop('pick', False)
         super().__init__(*args, **kwargs)
 
     def formfield(self, *args, **kwargs):
         field = super().formfield(*args, **kwargs)
         field.mask = self.mask
+        field.pick = self.pick
         return field
 
 class ForeignKey(ForeignKey):
@@ -138,3 +145,11 @@ class ImageField(ImageField):
 class Model(DjangoModel, ModelMixin):
     class Meta:
         abstract = True
+
+class Filter:
+
+    def get_label(self):
+        return None
+    
+    def choices(self, queryset):
+        return queryset