appier 1.32.0__tar.gz → 1.33.1__tar.gz

{appier-1.32.0/src/appier.egg-info → appier-1.33.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: appier
-Version: 1.32.0
+Version: 1.33.1
 Summary: Appier Framework
 Home-page: http://appier.hive.pt
 Author: Hive Solutions Lda.

{appier-1.32.0 → appier-1.33.1}/setup.py

@@ -44,7 +44,7 @@ def read_file(path):
 
 setuptools.setup(
     name="appier",
-    version="1.32.0",
+    version="1.33.1",
     author="Hive Solutions Lda.",
     author_email="development@hive.pt",
     description="Appier Framework",

{appier-1.32.0 → appier-1.33.1}/src/appier/__init__.py

@@ -268,7 +268,7 @@ from .preferences import (
 from .queuing import Queue, MemoryQueue, MultiprocessQueue, AMQPQueue
 from .redisdb import Redis
 from .request import CODE_STRINGS, Request, MockRequest
-from .scheduler import Scheduler
+from .scheduler import Scheduler, CronScheduler, SchedulerTask, SchedulerDate, Cron
 from .serialize import serialize_csv, serialize_ics, build_encoder
 from .session import (
     Session,

{appier-1.32.0 → appier-1.33.1}/src/appier/base.py

@@ -68,6 +68,7 @@ from . import compress
 from . import settings
 from . import observer
 from . import execution
+from . import scheduler
 from . import controller
 from . import structures
 from . import exceptions
@@ -93,7 +94,7 @@ NAME = "appier"
 """ The name to be used to describe the framework while working
 on its own environment, this is just a descriptive value """
 
-VERSION = "1.32.0"
+VERSION = "1.33.1"
 """ The version of the framework that is currently installed
 this value may be used for debugging/diagnostic purposes """
 
@@ -194,17 +195,17 @@ OCTET_TYPE = "application/octet-stream"
 """ The mime/content type to be used for octet stream based message payloads
 so that the legacy byte oriented value is readable """
 
-REPLACE_REGEX = re.compile("(?<!\(\?P)\<((\w+)(\([\"'].*?[\"']\))?:)?(\w+)\>")
+REPLACE_REGEX = re.compile(r"(?<!\(\?P)\<((\w+)(\([\"'].*?[\"']\))?:)?(\w+)\>")
 """ The regular expression to be used in the replacement
 of the capture groups for the urls, this regex will capture
 any named group not changed until this stage (eg: int,
 string, regex, etc.) """
 
-INT_REGEX = re.compile("\<int:(\w+)\>")
+INT_REGEX = re.compile(r"\<int:(\w+)\>")
 """ The regular expression to be used in the replacement
 of the integer type based groups for the urls """
 
-REGEX_REGEX = re.compile("\<regex\([\"'](.*?)[\"']\):(\w+)\>")
+REGEX_REGEX = re.compile(r"\<regex\([\"'](.*?)[\"']\):(\w+)\>")
 """ Regular expression that is going to be used for the
 replacement of regular expression types with the proper
 group in the final URL based route regex """
@@ -217,7 +218,9 @@ SLUGIER_REGEX_2 = re.compile(r"[-]+", re.UNICODE)  # @UndefinedVariable
 """ The second regular expression that is going to be used
 by the slugier sub system to replace some of its values """
 
-CSS_ABS_REGEX = re.compile(b"url\((?!(http:\/\/|https:\/\/|\/\/|\/))([^\)]+)\)")
+CSS_ABS_REGEX = re.compile(
+    legacy.bytes(r"url\((?!(http:\/\/|https:\/\/|\/\/|\/))([^\)]+)\)")
+)
 """ The regular expression that is going to be used to capture
 the relative CSS URL values, so that they may be converted into
 absolute ones for proper inlining, note that the regex is defined
@@ -425,6 +428,7 @@ class App(
         self._user_routes = None
         self._core_routes = None
         self._own = self
+        self._cron = None
         self._peers = {}
         self.__routes = []
         self.load(level=level, handlers=handlers)
@@ -730,6 +734,7 @@ class App(
         self._start_controllers()
         self._start_models()
         self._start_supervisor()
+        self._start_cron()
         if refresh:
             self.refresh()
         self.status = RUNNING
@@ -741,6 +746,7 @@ class App(
         self._print_bye()
         if refresh:
             self.refresh()
+        self._stop_cron()
         self._stop_supervisor()
         self._stop_models()
         self._stop_controllers()
@@ -2321,6 +2327,30 @@ class App(
         thread.daemon = True
         thread.start()
 
+    def cron(self, job, cron):
+        """
+        Schedule the provided method for regular execution using
+        the provided Cron like string.
+
+        The method is going to be executed at the provided time
+        in a separate thread.
+
+        :type job: function
+        :param job: The function/method that is going to be executed
+        at the specified time using the cron like string.
+        :type cron: String/SchedulerDate
+        :param cron: The cron like string that is going to be used to
+        define the execution time of the provided method.
+        :rtype: SchedulerTask
+        :return: The task that has been scheduled for execution at the
+        provided time.
+        """
+
+        if self._cron == None:
+            self._cron = scheduler.CronScheduler(self)
+            self._cron.start()
+        return self._cron.schedule(job, cron)
+
     def chunks(self, data, size=32768):
         for index in range(0, len(data), size):
             yield data[index : index + size]
@@ -2618,7 +2648,7 @@ class App(
         self.template_args(kwargs)
 
         # verifies if the target locale for the template has been defined
-        # and if thtat's the case updates the keyword based arguments for
+        # and if that's the case updates the keyword based arguments for
         # the current template render to include that value
         if locale:
             kwargs["_locale"] = locale
@@ -3763,8 +3793,8 @@ class App(
                 timeout = int(max_age)
 
             # in case the type of the resource is css an extra replace operation
-            # on the urls must be performed so that the base URL is added to all
-            # the resources, this is required so that relative urls are fixed
+            # on the URLs must be performed so that the base URL is added to all
+            # the resources, this is required so that relative URLs are fixed
             if type == "css":
                 base, _name = url.rsplit("/", 1)
                 base = legacy.bytes(base)
@@ -5356,6 +5386,16 @@ class App(
     def _stop_supervisor(self):
         pass
 
+    def _start_cron(self):
+        pass
+
+    def _stop_cron(self):
+        if not self._cron:
+            return
+        self._cron.stop()
+        self._cron.join()
+        self._cron = None
+
     def _add_route(self, *args, **kwargs):
         self.__routes.append(args)
         self.clear_routes()

{appier-1.32.0 → appier-1.33.1}/src/appier/legacy.py

@@ -30,6 +30,8 @@ __license__ = "Apache License, Version 2.0"
 
 import os
 import sys
+import calendar
+import datetime
 import inspect
 import functools
 import itertools
@@ -152,6 +154,10 @@ PYTHON_3 = sys.version_info[0] >= 3
 interpreter is at least Python 3 compliant, this is used
 to take some of the conversion decision for runtime """
 
+PYTHON_33 = sys.version_info[0] >= 3 and sys.version_info[1] >= 3
+""" Global variable that defines if the current Python
+interpreter is at least Python 3.3 compliant """
+
 PYTHON_35 = sys.version_info[0] >= 3 and sys.version_info[1] >= 5
 """ Global variable that defines if the current Python
 interpreter is at least Python 3.5 compliant """
@@ -538,6 +544,33 @@ def build_opener(*args, **kwargs):
         return urllib2.build_opener(*args, **kwargs)  # @UndefinedVariable
 
 
+def to_timestamp(date_time):
+    if PYTHON_33:
+        return date_time.replace(tzinfo=datetime.timezone.utc).timestamp()
+    else:
+        return calendar.timegm(date_time.utctimetuple())
+
+
+def to_datetime(timestamp):
+    if PYTHON_33:
+        return datetime.datetime.fromtimestamp(
+            timestamp, datetime.timezone.utc
+        ).replace(tzinfo=None)
+    else:
+        return datetime.datetime.utcfromtimestamp(timestamp)
+
+
+def utcfromtimestamp(timestamp):
+    return to_datetime(timestamp)
+
+
+def utc_now():
+    if PYTHON_33:
+        return datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None)
+    else:
+        return datetime.datetime.utcnow()
+
+
 def urlparse(*args, **kwargs):
     return _urlparse.urlparse(*args, **kwargs)
 

{appier-1.32.0 → appier-1.33.1}/src/appier/model.py

@@ -56,12 +56,14 @@ RE = lambda v: [i for i in v if not i == ""]
 empty element from the provided list values """
 
 BUILDERS = {
-    legacy.UNICODE: lambda v: v.decode("utf-8")
-    if isinstance(v, legacy.BYTES)
-    else legacy.UNICODE(v),
-    list: lambda v: RE(v)
-    if isinstance(v, list)
-    else (json.loads(v) if isinstance(v, legacy.UNICODE) else RE([v])),
+    legacy.UNICODE: lambda v: (
+        v.decode("utf-8") if isinstance(v, legacy.BYTES) else legacy.UNICODE(v)
+    ),
+    list: lambda v: (
+        RE(v)
+        if isinstance(v, list)
+        else (json.loads(v) if isinstance(v, legacy.UNICODE) else RE([v]))
+    ),
     dict: lambda v: json.loads(v) if isinstance(v, legacy.UNICODE) else dict(v),
     bool: lambda v: v if isinstance(v, bool) else not v in ("", "0", "false", "False"),
 }

appier-1.33.1/src/appier/scheduler.py

@@ -0,0 +1,287 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Hive Appier Framework
+# Copyright (c) 2008-2024 Hive Solutions Lda.
+#
+# This file is part of Hive Appier Framework.
+#
+# Hive Appier Framework is free software: you can redistribute it and/or modify
+# it under the terms of the Apache License as published by the Apache
+# Foundation, either version 2.0 of the License, or (at your option) any
+# later version.
+#
+# Hive Appier Framework is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# Apache License for more details.
+#
+# You should have received a copy of the Apache License along with
+# Hive Appier Framework. If not, see <http://www.apache.org/licenses/>.
+
+__author__ = "João Magalhães <joamag@hive.pt>"
+""" The author(s) of the module """
+
+__copyright__ = "Copyright (c) 2008-2024 Hive Solutions Lda."
+""" The copyright for the module """
+
+__license__ = "Apache License, Version 2.0"
+""" The license for the module """
+
+import time
+import heapq
+import calendar
+import datetime
+import logging
+import threading
+import traceback
+
+from . import config
+from . import legacy
+
+LOOP_TIMEOUT = 60.0
+""" The time value to be used to sleep the main sequence
+loop between ticks, this value should not be too small
+to spend many resources or to high to create a long set
+of time between external interactions """
+
+
+class Scheduler(threading.Thread):
+    """
+    Scheduler class that handles timeout based async tasks
+    within the context of an Appier application.
+
+    The architecture of the logic for the class should be
+    modular in the sense that new task may be added to
+    it through a queue or other external system. For that
+    a proper preemption mechanism should exist allowing
+    the scheduler to be stopped and started again.
+    """
+
+    def __init__(self, owner, timeout=LOOP_TIMEOUT, daemon=True):
+        threading.Thread.__init__(self, name="Scheduler")
+        self.owner = owner
+        self.timeout = config.conf("SCHEDULER_TIMEOUT", timeout, cast=float)
+        self.daemon = config.conf("SCHEDULER_DAEMON", daemon, cast=bool)
+        self._condition = threading.Condition()
+
+    def run(self):
+        self.running = True
+        self.load()
+        while self.running:
+            try:
+                self.tick()
+            except Exception as exception:
+                self.logger.critical("Unhandled scheduler exception raised")
+                self.logger.error(exception)
+                lines = traceback.format_exc().splitlines()
+                for line in lines:
+                    self.logger.warning(line)
+            self._condition.acquire()
+            self._condition.wait(self.timeout)
+            self._condition.release()
+
+    def stop(self, awake=True):
+        self.running = False
+        if awake:
+            self.awake()
+
+    def tick(self):
+        pass
+
+    def load(self):
+        pass
+
+    def awake(self):
+        self._condition.acquire()
+        self._condition.notify()
+        self._condition.release()
+
+    @property
+    def logger(self):
+        if self.owner:
+            return self.owner.logger
+        else:
+            return logging.getLogger()
+
+
+class CronScheduler(Scheduler):
+    """
+    Specialized version of the scheduler that runs tasks
+    based on a cron like configuration.
+
+    The tasks are defined in a cron like format and are
+    executed based on the current time.
+    """
+
+    def __init__(self, owner, timeout=LOOP_TIMEOUT, daemon=True):
+        Scheduler.__init__(self, owner, timeout=timeout, daemon=daemon)
+        self._tasks = []
+
+    def tick(self, now_ts=None):
+        current_ts = lambda: now_ts if now_ts else time.time()
+        current_dt = lambda: (
+            legacy.to_datetime(now_ts) if now_ts else legacy.utc_now()
+        )
+
+        timestamp = current_ts() + 5.0
+
+        while True:
+            if not self._tasks:
+                break
+
+            timestamp, task = self._tasks[0]
+            if timestamp > current_ts():
+                break
+
+            heapq.heappop(self._tasks)
+
+            if task.enabled:
+                task.job()
+                heapq.heappush(
+                    self._tasks, (task.next_timestamp(now=current_dt()), task)
+                )
+
+        self.timeout = max(0, timestamp - current_ts())
+
+    def schedule(self, job, cron, now=None):
+        """
+        Schedules the provided job function for execution according
+        to the provided cron string.
+
+        The optional now parameter may be used to provide the current
+        time reference for the scheduling operation, meaning that the next
+        timestamp will be calculated using this value as reference.
+
+        :type job: Function
+        :param job: The function to be executed as the job.
+        :type cron: String/SchedulerDate
+        :param cron: The cron like string defining the schedule.
+        :type now: datetime
+        :param now: Optional time reference for the job scheduling.
+        :rtype: SchedulerTask
+        :return: The task object that was created for the job.
+        """
+
+        task = SchedulerTask(job, cron)
+        heapq.heappush(self._tasks, (task.next_timestamp(now=now), task))
+        self.awake()
+        return task
+
+    def next_run(self):
+        timestamp = self.next_timestamp()
+        if not timestamp:
+            return None
+        return legacy.to_datetime(timestamp)
+
+    def next_timestamp(self):
+        if not self._tasks:
+            return None
+        return self._tasks[0][0]
+
+
+class SchedulerTask(object):
+
+    def __init__(self, job, cron):
+        self.job = job
+        self.date = SchedulerDate.from_cron(cron)
+        self._enabled = True
+
+    def enable(self):
+        self._enabled = True
+
+    def disable(self):
+        self._enabled = False
+
+    def next_run(self, now=None):
+        return self.date.next_run(now=now)
+
+    def next_timestamp(self, now=None):
+        return self.date.next_timestamp(now=now)
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+
+class SchedulerDate(object):
+
+    def __init__(
+        self, minutes="*", hours="*", days_of_month="*", months="*", days_of_week="*"
+    ):
+        self.minutes = self._parse_field(minutes, 0, 59)
+        self.hours = self._parse_field(hours, 0, 23)
+        self.days_of_month = self._parse_field(days_of_month, 1, 31)
+        self.months = self._parse_field(months, 1, 12)
+        self.days_of_week = self._parse_field(days_of_week, 0, 6)
+
+    @classmethod
+    def from_cron(cls, cron):
+        if isinstance(cron, cls):
+            return cron
+        values = (value.strip().split(",") for value in cron.split(" "))
+        return cls(*values)
+
+    def next_timestamp(self, now=None):
+        date = self.next_run(now=now)
+        return legacy.to_timestamp(date)
+
+    def next_run(self, now=None):
+        """
+        Calculate the next run time starting from the current time.
+        This operation is done respecting Cron rules.
+
+        :type now: datetime
+        :param now: Optional date time to be used as the current time.
+        :rtype: datetime
+        :return: The next run time respecting Cron rules.
+        """
+
+        now = now or legacy.utc_now()
+        now_day = datetime.datetime(now.year, now.month, now.day)
+        now_hour = datetime.datetime(now.year, now.month, now.day, hour=now.hour)
+        now_minute = datetime.datetime(
+            now.year, now.month, now.day, hour=now.hour, minute=now.minute
+        )
+
+        year = now.year
+
+        while True:
+            for month in sorted(self.months):
+                if month < now.month and year < now.year:
+                    continue
+
+                for day in sorted(self.days_of_month):
+                    try:
+                        date = datetime.datetime(year, month, day)
+                    except ValueError:
+                        continue
+                    if self.days_of_week and not date.weekday() in self.days_of_week:
+                        continue
+                    if date < now_day:
+                        continue
+
+                    for hour in sorted(self.hours):
+                        if date.replace(hour=hour) < now_hour:
+                            continue
+
+                        for minute in sorted(self.minutes):
+                            _date = date.replace(
+                                hour=hour, minute=minute, second=0, microsecond=0
+                            )
+                            if _date > now_minute:
+                                return _date
+
+            year += 1
+
+    def _parse_field(self, field, min_value, max_value):
+        if field in ("*", ["*"], ("*",)):
+            return set(range(min_value, max_value + 1))
+        elif isinstance(field, (list, tuple)):
+            return set(int(v) for v in field)
+        else:
+            return set((int(field),))
+
+
+class Cron(object):
+    pass

{appier-1.32.0 → appier-1.33.1}/src/appier/test/base.py

@@ -275,7 +275,9 @@ class BaseTest(unittest.TestCase):
         self.assertEqual(type(result), str)
         self.assertEqual(result, "%e4%bd%a0%e5%a5%bd%e4%b8%96%e7%95%8c")
 
-        result = self.app.slugify_slugier(appier.legacy.bytes("你好世界", encoding="utf-8"))
+        result = self.app.slugify_slugier(
+            appier.legacy.bytes("你好世界", encoding="utf-8")
+        )
         self.assertEqual(type(result), str)
         self.assertEqual(result, "%e4%bd%a0%e5%a5%bd%e4%b8%96%e7%95%8c")
 
@@ -385,3 +387,19 @@ class BaseTest(unittest.TestCase):
         self.assertEqual(result, appier.legacy.u("olá"))
         result = self.app.template(template, locale="en_us")
         self.assertEqual(result, appier.legacy.u("hello"))
+
+    def test_css_abs(self):
+        result = appier.base.CSS_ABS_REGEX.sub(
+            b"url(http://www.example/\\2)", b"url(image.jpg)"
+        )
+        self.assertEqual(result, b"url(http://www.example/image.jpg)")
+
+        result = appier.base.CSS_ABS_REGEX.sub(
+            b"url(https://www.example/\\2)", b"url(image.jpg)"
+        )
+        self.assertEqual(result, b"url(https://www.example/image.jpg)")
+
+        result = appier.base.CSS_ABS_REGEX.sub(
+            b"url(http://www.example/\\2)", b"url(https://example.com/image.jpg)"
+        )
+        self.assertEqual(result, b"url(https://example.com/image.jpg)")