slthcore 0.6.5__tar.gz

slthcore-0.6.5/MANIFEST.in

@@ -0,0 +1,4 @@
+include requirements.txt
+recursive-include slth/static *.*
+recursive-include slth/templates *.*
+recursive-include slth/cmd *.*

slthcore-0.6.5/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: slthcore
+Version: 0.6.5
+Summary: API generator based on yml file
+Home-page: https://github.com/brenokcc
+Author: Breno Silva
+Author-email: brenokcc@yahoo.com.br
+License: BSD License
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content

slthcore-0.6.5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

slthcore-0.6.5/setup.py

@@ -0,0 +1,27 @@
+from setuptools import find_packages, setup
+
+install_requires = []
+
+setup(
+    name='slthcore',
+    version='0.6.5',
+    packages=find_packages(),
+    install_requires=install_requires,
+    include_package_data=True,
+    license='BSD License',
+    description='API generator based on yml file',
+    long_description='',
+    url='https://github.com/brenokcc',
+    author='Breno Silva',
+    author_email='brenokcc@yahoo.com.br',
+    classifiers=[
+        'Environment :: Web Environment',
+        'Framework :: Django',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: BSD License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        'Topic :: Internet :: WWW/HTTP',
+        'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
+    ],
+)

slthcore-0.6.5/slth/__init__.py

@@ -0,0 +1,270 @@
+import json
+import warnings
+from pathlib import Path
+from datetime import datetime, date
+from django.db import models
+from .queryset import QuerySet
+from django.db.models import manager
+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.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
+from .threadlocal import tl
+from django.apps import apps as django_apps
+
+from decimal import Decimal
+
+warnings.filterwarnings('ignore', module='urllib3')
+
+FILENAME = 'application.yml'
+ENDPOINTS = {}
+PROXIED_MODELS = []
+THREADS = []
+
+class JSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, Decimal):
+            return dict(type='decimal', value=float(obj))
+        elif isinstance(obj, datetime):
+            return dict(type='datetime', value=obj.isoformat())
+        elif isinstance(obj, date):
+            return dict(type='date', value=obj.isoformat())
+        elif isinstance(obj, QuerySet):
+            return dict(type='queryset', value=obj.dump())
+        elif isinstance(obj, Model):
+            return dict(type='object', model=obj._meta.label.lower(), pk=obj.pk)
+        return json.JSONEncoder.default(self, obj)
+
+
+class JSONDecoder(json.JSONDecoder):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(object_hook=self.object_hook, *args, **kwargs)
+
+    def object_hook(self, obj):
+        type = obj.get('type')
+        if type:
+            if type == 'decimal':
+                return Decimal(obj['value'])
+            elif type == 'datetime':
+                return datetime.fromisoformat(obj['value'])
+            elif type == 'date':
+                return date.fromisoformat(obj['value'])
+            elif type == 'queryset':
+                return QuerySet.load(obj['value'])
+            elif type == 'object':
+                return django_apps.get_model(obj['model']).objects.get(pk=obj['pk'])
+        return obj
+
+
+def dumps(data, indent=1, ensure_ascii=False):
+    return json.dumps(data, indent=indent, ensure_ascii=ensure_ascii, cls=JSONEncoder)
+
+
+def loads(data):
+    return json.loads(data, cls=JSONDecoder)
+
+
+class BaseManager(manager.BaseManager):
+    def get_queryset(self):
+        return super().get_queryset()
+
+    def all(self):
+        return self.get_queryset().all()
+
+    def __call__(self, model):
+        return django_apps.get_model(model)
+
+
+class Manager(BaseManager.from_queryset(QuerySet)):
+    pass
+
+
+models.QuerySet = QuerySet
+models.Manager = Manager
+setattr(options, 'DEFAULT_NAMES', options.DEFAULT_NAMES + ('icon', 'search_fields'))
+
+
+
+class ModelMixin(object):
+
+    @classmethod
+    def get_field(cls, lookup):
+        model = cls
+        attrs = lookup.split('__')
+        while attrs:
+            attr_name = attrs.pop(0)
+            if attrs:  # go deeper
+                field = model._meta.get_field(attr_name)
+                model = field.related_model
+            else:
+                try:
+                    return model._meta.get_field(attr_name)
+                except FieldDoesNotExist:
+                    pass
+        return None
+
+    def getroles(self, username_lookup='username'):
+        roles = getattr(self, '_roles', None)
+        if roles is None:
+            obj = self
+            for attr_name in username_lookup.split('__'):
+                obj = getattr(obj, attr_name)
+            roles = django_apps.get_model('api.role').objects.filter(username=obj)
+            setattr(self, '_roles', roles)
+        return roles
+
+    def getuser(self, username_lookup):
+        obj = self
+        for attr_name in username_lookup.split('__'):
+            obj = getattr(obj, attr_name)
+        return django_apps.get_model('auth.user').objects.get(username=obj)
+    
+    def serializer(self) -> Serializer:
+        return Serializer(self)
+    
+    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  = 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)
+                    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:
+                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)
+        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__
+
+
+def __new__(mcs, name, bases, attrs, **kwargs):
+    if attrs['__module__'] != '__fake__':
+        # See .db.models.Manager
+        if 'objects' in attrs and isinstance(attrs['objects'], QuerySet):
+            queryset_class = attrs['objects']
+            attrs.update(objects=BaseManager.from_queryset(type(queryset_class))())
+        # Defining the objects Manager using .db.models.QuerySet
+        if 'objects' not in attrs and not all(['objects' in dir(cls) for cls in bases]):
+            attrs.update(objects=BaseManager.from_queryset(QuerySet)())
+
+    if ModelMixin not in bases:
+        bases = bases + (ModelMixin, )
+    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
+
+
+ModelBase.__new__ = __new__
+
+
+def api_watchdog(sender, **kwargs):
+    sender.extra_files.add(Path('application.yml'))
+
+autoreload_started.connect(api_watchdog)
+
+
+def meta(verbose_name=None):
+    def decorate(function):
+        function.verbose_name = verbose_name
+        return function
+    return decorate
+
+
+original_trigger_reload = autoreload.trigger_reload
+
+def trigger_reload(filename):
+    print('Stoping sloth thread....')
+    for thread in THREADS:
+        thread.stop()
+        thread.join()
+    print('Thread stopped!')
+    original_trigger_reload(filename)
+
+autoreload.trigger_reload = trigger_reload

slthcore-0.6.5/slth/application.py

@@ -0,0 +1,252 @@
+
+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, name, color="black", background="inherite", border="none"):
+        self.name = name
+        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
+
+    def to_css(self):
+        return f"""
+            --{self.name}-color: { self.color };
+            --{self.name}-border: { self.border };
+            --{self.name}-background: { self.background };
+        """
+
+class ColorSchema:
+    def to_css(self):
+        css = []
+        css.append("<style>")
+        css.append(":root{")
+        css.append(f"--border-radius: {self.border_radius}px;")
+        css.append(self.default.to_css())
+        css.append(self.header.to_css())
+        css.append(self.footer.to_css())
+        css.append(self.fieldset.to_css())
+        css.append(self.input.to_css())
+        css.append(self.primary.to_css())
+        css.append(self.secondary.to_css())
+        css.append(self.auxiliary.to_css())
+        css.append(self.highlight.to_css())
+        css.append(self.info.to_css())
+        css.append(self.success.to_css())
+        css.append(self.warning.to_css())
+        css.append(self.danger.to_css())
+        css.append("</style>")
+        return "\n".join(css)
+
+
+class Light(ColorSchema):
+    def __init__(self):
+        self.border_radius = 0
+        self.default: Style = Style("default", color="#383838", background="#FFFFFF")
+        self.header: Style = Style("header", color="#383838", background="#FFFFFF")
+        self.footer: Style = Style("footer", color="#383838", background="#FFFFFF")
+        self.fieldset: Style = Style("fieldset", color="#383838", background="#FFFFFF")
+        self.input: Style = Style("input", border="solid 1px #d9d9d9", background="#FFFFFF")
+        self.primary:Style = Style("primary", color="#1351b4", background="#1351b4")
+        self.secondary:Style = Style("secondary", color="#071e41")
+        self.auxiliary:Style = Style("auxiliary", color="#2670e8", background="#f8f8f8")
+        self.highlight:Style = Style("hightlight", color="#0c326f")
+        self.info:Style = Style("info", color="#1351b4", background="#d4e5ff")
+        self.success:Style = Style("success", color="#ffffff", background="#1351b4")
+        self.warning:Style = Style("warning", color="#fff5c2")
+        self.danger:Style = Style("danger", color="#e52207")
+
+
+class Dark(ColorSchema):
+    def __init__(self):
+        self.border_radius = 3
+        self.default: Style = Style("default", color="#c3d0e5", background="#0D1117")
+        self.header: Style = Style("header", color="#383838", background="#FFFFFF")
+        self.footer: Style = Style("footer", color="#383838", background="#FFFFFF")
+        self.fieldset: Style = Style("fieldset", color="#91aad2", background="#262c35")
+        self.input: Style = Style("input", border="0", background="#0D1117")
+        self.primary:Style = Style("primary", color="#c3d0e5", background="#90C4F9")
+        self.secondary:Style = Style("secondary", color="#071e41")
+        self.auxiliary:Style = Style("auxiliary", color="#91aad2", background="#262c35")
+        self.highlight:Style = Style("hightlight", color="#0c326f")
+        self.info:Style = Style("info", color="#c3d0e5", background="#262c35")
+        self.success:Style = Style("success", color="#c3d0e5", background="#121f1a", border="1px solid #3b622b")
+        self.warning:Style = Style("warning", color="#fff5c2")
+        self.danger:Style = Style("danger", color="#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_username, user_email=None, user_scope=None, user_create=False, user_logout_url=None):
+        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_username=user_username, user_email=user_email, user_scope=user_scope, user_create=user_create, user_logout_url=user_logout_url))
+
+    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.todo: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 Theme:
+    def __init__(self):
+        self.light = Light()
+        self.dark = Dark()
+
+
+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.brand = None
+        self.version =  "0.0.1"
+        self.oauth:Oauth = Oauth()
+        self.groups:Groups = Groups()
+        self.menu:Menu = Menu()
+        self.dashboard = Dashboard()
+        self.theme:Theme = Theme()
+        self.sponsors:List = List()
+
+    def load(self):
+        pass
+
+    def serialize(self, request):
+        icon = build_url(request, self.icon)
+        logo = build_url(request, self.brand or self.logo)
+        title = self.title if self.brand is None else None
+        if request.user.is_authenticated:
+            name = request.user.first_name
+            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:
+            name = user = profile = photo = None
+        
+        def contribute(endpoint_list, endpoint_name):
+            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)
+                endpoint_list.append(dict(name=name, url=url, modal=modal, icon=icon))
+        
+        endpoints = {"actions": [], "usermenu": [], "adder": [], "settings": [], "tools": [], "toolbar": []}
+        for entrypoint in endpoints:
+            for endpoint_name in getattr(self.dashboard, entrypoint):
+                contribute(endpoints[entrypoint], endpoint_name)
+
+        top = []
+        for endpoint_name in self.dashboard.top:
+            contribute(top, endpoint_name)
+        
+        return dict(
+            type="application",
+            icon=icon,
+            navbar=dict(
+                type="navbar", title=title, subtitle=self.subtitle, logo=logo, user=user, name=name, **endpoints
+            ),
+            menu=dict(
+                type="menu", items=self.menu.process(request), user=user, image=photo
+            ),
+            footer=dict(
+                type="footer", version=self.version
+            ),
+            top=top,
+            oauth=self.oauth.serialize(),
+            sponsors=self.sponsors
+        )
+    
+    @staticmethod
+    def get_instance():
+        instance = APPLICATION_CLASS()
+        instance.load()
+        return instance
+

slthcore-0.6.5/slth/apps.py

@@ -0,0 +1,44 @@
+import os
+import time
+from datetime import datetime
+from django.conf import settings
+from django.apps import AppConfig
+from django.utils import autoreload
+from django.apps import apps
+import threading
+from . import THREADS
+
+
+
+
+class Thread(threading.Thread):
+    def __init__(self):
+        super().__init__()
+        self._stop_event = threading.Event()
+
+    def run(self):
+        while not self._stop_event.is_set():
+            # print('.')
+            apps.get_model("slth", "email").objects.send()
+            apps.get_model("slth", "pushnotification").objects.send()
+            apps.get_model("slth", "job").objects.execute()
+            for i in range(0, 10):
+                if self._stop_event.is_set():
+                    break
+                time.sleep(1)
+    
+    def stop(self):
+        print("Stopping e-mail thread...")
+        self._stop_event.set()
+
+
+class AppConfig(AppConfig):
+    name = 'slth'
+
+    def ready(self):
+        settings.SLOTH = True
+        if os.environ.get("RUN_MAIN"):
+            print('Starting sloth thread...')
+            thread = Thread()
+            thread.start()
+            THREADS.append(thread)