django-restit 4.2.173__tar.gz → 4.2.174__tar.gz

{django_restit-4.2.173 → django_restit-4.2.174}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-restit
-Version: 4.2.173
+Version: 4.2.174
 Summary: A Rest Framework for DJANGO
 License: MIT
 Author: Ian Starnes

{django_restit-4.2.173 → django_restit-4.2.174}/account/models/group.py

@@ -118,6 +118,7 @@ class Group(models.Model, RestModel, MetaDataModel):
                 "kind",
                 ("metadata__timezone", "timezone"),
                 ("metadata__eod", "end_of_day"),
+                ("parent__pk", "parent_id"),
                 ("parent__name", "parent"),
                 ("location.line1", "address_line1"),
                 ("location.line2", "address_line2"),
@@ -171,7 +172,7 @@ class Group(models.Model, RestModel, MetaDataModel):
             if item:
                 return item.thumbnail_url()
         return None
-        
+
     @classmethod
     def on_rest_list_filter(cls, request, qset=None):
         if not request.member.hasPermission("view_all_groups"):
@@ -231,7 +232,7 @@ class Group(models.Model, RestModel, MetaDataModel):
                 raise RestValidationError("cannot set self as parent", 1101)
             value = Group.objects.filter(pk=value).last()
         self.parent = value
-    
+
     def set_child_of(self, value):
         # this is a helper to add this group to another group
         parent = Group.objects.filter(pk=value).last()
@@ -321,7 +322,7 @@ class Group(models.Model, RestModel, MetaDataModel):
                 return True
         return False
 
-    def notifyMembers(self, subject, message=None, template=None, context=None, 
+    def notifyMembers(self, subject, message=None, template=None, context=None,
                       email_only=False, sms_msg=None, perms=None, force=False,
                       from_email=None, exclude_member=None):
         if perms is not None:
@@ -436,19 +437,19 @@ class Group(models.Model, RestModel, MetaDataModel):
         qset = self.memberships.filter(state__gte=-10)
         if perms:
             qset = qset.filter(
-                Q(properties__category="permissions", 
-                  properties__key__in=perms, 
-                  properties__value__in=TRUE_VALUES) | 
-                Q(member__properties__category="permissions", 
-                  member__properties__key__in=perms, 
+                Q(properties__category="permissions",
+                  properties__key__in=perms,
+                  properties__value__in=TRUE_VALUES) |
+                Q(member__properties__category="permissions",
+                  member__properties__key__in=perms,
                   member__properties__value__in=TRUE_VALUES))
         if notify:
             qset = qset.filter(
-                Q(properties__category="notify", 
-                  properties__key__in=notify, 
-                  properties__value__in=TRUE_VALUES) | 
-                Q(member__properties__category="notify", 
-                  member__properties__key__in=notify, 
+                Q(properties__category="notify",
+                  properties__key__in=notify,
+                  properties__value__in=TRUE_VALUES) |
+                Q(member__properties__category="notify",
+                  member__properties__key__in=notify,
                   member__properties__value__in=TRUE_VALUES))
 
         if role:
@@ -495,7 +496,7 @@ class Group(models.Model, RestModel, MetaDataModel):
             # enable again?
             ms.set_state(0)
             ms.save()
-            
+
         if MEMBERSHIP_ROLES:
             perms = MEMBERSHIP_ROLES.get(role, [])
             for k in perms:
@@ -601,12 +602,8 @@ class Group(models.Model, RestModel, MetaDataModel):
         if credentials.kind == "member":
             if msg.pk is not None:
                 return credentials.instance.isMemberOf(msg.pk)
-        return False         
+        return False
 
 
 class GroupMetaData(MetaDataBase):
     parent = models.ForeignKey(Group, related_name="properties", on_delete=models.CASCADE)
-
-
-
-

{django_restit-4.2.173 → django_restit-4.2.174}/auditlog/models.py

@@ -55,10 +55,11 @@ class PersistentLog(models.Model, RestModel):
     class RestMeta:
         DEFAULT_SORT = "-when"
         CAN_SAVE = False
+        ESTIMATE_COUNTS = True
         GROUP_FIELD = None  # do this so when we sort by group it is always exact
         QUERY_FIELDS = [
-            "level", "component", "pkey", "action", 
-            "request_method", "request_path", 
+            "level", "component", "pkey", "action",
+            "request_method", "request_path",
             "session__ip", "user",
             "tid", "group", "user__username"]
         SEARCH_FIELDS = ["user__username", "user__last_name", "message", "session__ip", "request_path"]

{django_restit-4.2.173 → django_restit-4.2.174}/incident/models/event.py

@@ -18,8 +18,8 @@ INCIDENT_EVENT_GRANULARITY = settings.get("INCIDENT_EVENT_GRANULARITY", "hourly"
 EVENT_TO_INCIDENT_LEVEL = settings.get("EVENT_TO_INCIDENT_LEVEL", 4)
 EVENT_DETAIL_TEMPLATES = settings.get("EVENT_DETAIL_TEMPLATES", None)
 EVENT_META_KEYWORDS = settings.get("EVENT_META_KEYWORDS", [
-        "path", "ip", "reporter_ip", "code", 
-        "reason", "buid", "merchant", "tid", 
+        "path", "ip", "reporter_ip", "code",
+        "reason", "buid", "merchant", "tid",
         "group", "http_user_agent", "user_agent",
         "app_url", "isp", "city", "state", "country",
         "username"
@@ -28,7 +28,7 @@ EVENT_META_KEYWORDS = settings.get("EVENT_META_KEYWORDS", [
 logger = log.getLogger("incident", filename="incident.log")
 
 """
-very generic 
+very generic
 external system can post an event
 {
      "description": "Critical Test Event",
@@ -77,15 +77,15 @@ class Event(JSONMetaData, rm.RestModel):
     # code = models.IntegerField(default=0, db_index=True)
 
     group = models.ForeignKey(
-        "account.Group", on_delete=models.SET_NULL, 
+        "account.Group", on_delete=models.SET_NULL,
         related_name="+", null=True, default=None)
- 
+
     component = models.SlugField(max_length=250, null=True, blank=True, default=None)
     component_id = models.IntegerField(null=True, blank=True, default=None)
 
     # this allows us to bundle multiple events to an incident
     incident = models.ForeignKey(
-        Incident, null=True, default=None, 
+        Incident, null=True, default=None,
         related_name="events", on_delete=models.SET_NULL)
 
     def runRules(self):
@@ -170,14 +170,14 @@ class Event(JSONMetaData, rm.RestModel):
             # logger.info(f"ignore event {self.pk} {self.description}")
             return
 
-        # always create an incident 
+        # always create an incident
         if incident is None:
             incident = Incident(
                 rule=hit_rule, priority=priority,
                 reporter_ip=self.reporter_ip,
                 category=self.category,
                 group=self.group,
-                component=self.component, 
+                component=self.component,
                 component_id=self.component_id,
                 hostname=self.hostname)
             if self.group is None and hit_rule is not None:
@@ -211,4 +211,3 @@ class Event(JSONMetaData, rm.RestModel):
             incident.triggerAction()
         except Exception:
             logger.exception()
-

{django_restit-4.2.173 → django_restit-4.2.174}/incident/models/incident.py

@@ -92,7 +92,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
 
     group = models.ForeignKey("account.Group", on_delete=models.SET_NULL, null=True, default=None)
     assigned_to = models.ForeignKey("account.Member", on_delete=models.SET_NULL, null=True, default=None)
-    
+
     priority = models.IntegerField(default=0)  # 1-10, 1 being the highest
     # 0=new, 1=opened, 2=paused, 3=ignore, 4=resolved, 5=pending
     state = models.IntegerField(default=0, choices=INCIDENT_STATES)
@@ -160,7 +160,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
 
         if event.details:
             self.setProperty("details", event.details)
-    
+
         if event.metadata.geoip and event.metadata.geoip.city:
             self.setProperty("city", event.metadata.geoip.city)
             self.setProperty("state", event.metadata.geoip.state)
@@ -209,7 +209,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
                 self.save()
             elif self.rule.action.startswith("firewall_block"):
                 if settings.FIREWALL_GLOBAL_BLOCK:
-                    Task.Publish("incident", "firewall_block", 
+                    Task.Publish("incident", "firewall_block",
                                  dict(ip=self.reporter_ip),
                                  channel="tq_broadcast")
 
@@ -348,7 +348,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
             member.sendSMS(sms_msg)
         members = group.getMembers(perms=email_perms, as_member=True)
         for member in members:
-            member.sendEmail(subject, body)       
+            member.sendEmail(subject, body)
 
     def notifyWith(self, perm):
         # logger.info("notifyWith", perm)
@@ -407,7 +407,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
             if request != None and "DATA" in request and "note" in request.DATA:
                 self.logHistory(kind="note", note=request.DATA.get("note"), request=request)
 
-    def logHistory(self, kind="history", note=None, media=None, 
+    def logHistory(self, kind="history", note=None, media=None,
                    request=None, member=None, notify=True):
         if request is None:
             request = self.getActiveRequest()
@@ -493,7 +493,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
                 email_only=True,
                 from_email=INCIDENT_EMAIL_FROM)
         else:
-            # notitfy everyone but the sender          
+            # notitfy everyone but the sender
             if history.by is None:
                 members = Member.GetWithPermission(perm, ignore_disabled_email=True).exclude(pk=history.by.pk)
                 if members.count() == 0:

{django_restit-4.2.173 → django_restit-4.2.174}/incident/models/ossec.py

@@ -46,8 +46,8 @@ class ServerOssecAlert(models.Model, rm.RestModel):
     level       = models.IntegerField(default=0)
     title       = models.CharField(max_length=200, blank=True, null=True, default=None)
     geoip       = models.ForeignKey("location.GeoIP", blank=True, null=True, default=None, on_delete=models.DO_NOTHING)
-    
+
     metadata = None
-    
+
     def __str__(self):
         return f'{self.hostname}: {self.title}'

{django_restit-4.2.173 → django_restit-4.2.174}/metrics/models.py

@@ -43,14 +43,14 @@ def metric(
         elif granularity in ["minutes", "seconds"]:
             expires = datetime.now() + timedelta(days=7)
         m, created = Metrics.objects.get_or_create(
-            uuid=key, 
+            uuid=key,
             defaults=dict(
                 granularity=granularity, slug=slug, expires=expires,
                 group=group, start=utils.date_for_granulatiry(date, granularity)))
         m.updateMetrics(keys, data, created)
 
 
-def gauge(slug, keys, data, granularity="daily", group=None, date=None, 
+def gauge(slug, keys, data, granularity="daily", group=None, date=None,
           timezone=None, slug_append=None, max_granularity=None):
     # guage does not accumulate but just stores the data like a cache
     # if calledf on the same time period it will just update the current numbers
@@ -72,7 +72,7 @@ def gauge(slug, keys, data, granularity="daily", group=None, date=None,
         elif gran == "daily":
             expires = datetime.now() + timedelta(days=METRICS_EXPIRE_DAILY)
         m, created = Metrics.objects.get_or_create(
-            uuid=key, 
+            uuid=key,
             defaults=dict(
                 granularity=gran, slug=slug, expires=expires,
                 group=group, start=utils.date_for_granulatiry(date, gran)))
@@ -99,7 +99,7 @@ def get_qset(slug, granularity, start=None, end=None,
         start = group.getLocalTime(start)
     elif settings.METRICS_TIMEZONE:
         start = date_util.convertToLocalTime(settings.METRICS_TIMEZONE, start)
-  
+
     start = utils.date_for_granulatiry(start, granularity)
     if end is None:
         if granularity == "hourly":
@@ -133,7 +133,7 @@ def get_totals(slug, keys, granularity, start=None, end=None, group=None):
         start = group.getLocalTime(start)
     elif settings.METRICS_TIMEZONE:
         start = date_util.convertToLocalTime(settings.METRICS_TIMEZONE, start)
-  
+
     start = utils.date_for_granulatiry(start, granularity)
     if end is None:
         end = start + timedelta(minutes=5)
@@ -141,7 +141,7 @@ def get_totals(slug, keys, granularity, start=None, end=None, group=None):
         end = group.getLocalTime(end)
     elif settings.METRICS_TIMEZONE:
         end = date_util.convertToLocalTime(settings.METRICS_TIMEZONE, end)
-    
+
     qset = Metrics.objects.filter(
         slug=slug, granularity=granularity,
         group=group, start__gte=start, start__lte=end)
@@ -162,7 +162,7 @@ def get_metric(slug, granularity, start, group=None):
         start = group.getLocalTime(start)
     elif settings.METRICS_TIMEZONE:
         start = date_util.convertToLocalTime(settings.METRICS_TIMEZONE, start)
-  
+
     start = utils.date_for_granulatiry(start, granularity)
     qset = Metrics.objects.filter(
         slug=slug, granularity=granularity, start__gte=start, start__lte=start, group=group)
@@ -226,7 +226,7 @@ def get_metrics(slug, granularity, start, end=None, group=None, samples=None):
             for k in keys:
                 data[k].append(0)
             continue
-        for k in keys: 
+        for k in keys:
             data[k].append(result["values"].get(k, 0))
         period_values.remove(result)
     return objict(periods=periods, data=data)
@@ -241,7 +241,7 @@ def get_chart_periods(slug, granularity, start, end=None, group=None):
         periods.append(period)
     if granularity != "weekly":
         periods.reverse()
-    return periods   
+    return periods
 
 
 def get_adjusted_date_range(granularity, start, end, group=None, samples=None):
@@ -282,6 +282,7 @@ def generate_uuid(slug, group, slug_append=None):
 class Metrics(models.Model, rm.RestModel):
     class RestMeta:
         QUERY_FIELDS = ["group__kind", "all_fields"]
+        ESTIMATE_COUNTS = True
         GRAPHS = {
             "detailed": {
                 "fields": [
@@ -310,7 +311,7 @@ class Metrics(models.Model, rm.RestModel):
     # allow to group metrics by a group
     group = models.ForeignKey("account.Group", related_name="+", on_delete=models.CASCADE, null=True, default=None)
 
-    # now we create a set of k/v 
+    # now we create a set of k/v
     k1 = models.SlugField(max_length=64, null=True, default=None)
     v1 = models.BigIntegerField(default=0)
 

{django_restit-4.2.173 → django_restit-4.2.174}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-restit"
-version = "4.2.173"
+version = "4.2.174"
 description = "A Rest Framework for DJANGO"
 authors = ["Ian Starnes <ians@311labs.com>"]
 license = "MIT"

{django_restit-4.2.173 → django_restit-4.2.174}/rest/__init__.py

@@ -1,4 +1,4 @@
 from .uberdict import UberDict  # noqa: F401
 from .settings_helper import settings  # noqa: F401
 
-__version__ = "4.2.173"
+__version__ = "4.2.174"

{django_restit-4.2.173 → django_restit-4.2.174}/rest/models/base.py

@@ -7,6 +7,7 @@ import importlib
 from django.db import models as dm
 from django.db.transaction import atomic
 from django.apps import apps
+from django.db import connection
 
 from rest import helpers as rh
 from rest import errors as re
@@ -876,7 +877,7 @@ class RestModel(object):
         if not graph and request is not None:
             graph = request.DATA.get("graph", "default")
         return GRAPH_HELPERS.restList(
-            request, qset, sort=sort, totals=totals, 
+            request, qset, sort=sort, totals=totals,
             return_httpresponse=return_httpresponse,
             response_params=dict(graph=graph),
             **cls.getGraph(graph))
@@ -896,6 +897,17 @@ class RestModel(object):
             request = cls.getActiveRequest()
         return cls.restList(request, qset, graph, totals, False)
 
+    @classmethod
+    def restListEstimatedCount(cls, request, qset):
+        # TODO attempt to make this work with the qset,
+        # right now it gets an estimated count of the entire table
+        if getattr(cls.RestMeta, "ESTIMATE_COUNTS", False):
+            if connection.vendor == 'postgresql':
+                with connection.cursor() as cursor:
+                    cursor.execute(f"SELECT reltuples::bigint FROM pg_class WHERE relname = '{cls._meta.db_table}'")
+                    return cursor.fetchone()[0]
+        return qset.count()
+
     def restStatus(self, request, status, **kwargs):
         RestModel._setupGraphHelpers()
         return GRAPH_HELPERS.restStatus(request, status, **kwargs)
@@ -959,7 +971,7 @@ class RestModel(object):
         has_perms = True
         if perms is not None:
             has_perms = cls.on_rest_list_has_perms(request, perms, qset)
-        
+
         if request.group:
             qset = cls.on_rest_filter_children(request, qset)
         if not has_perms:
@@ -1040,7 +1052,7 @@ class RestModel(object):
         elif dr_offset > 0:
             dr_start = dr_start + timedelta(minutes=dr_offset)
             dr_end = dr_end + timedelta(minutes=dr_offset)
-    
+
         rh.debug("tr_end changing", str(dr_start), str(dr_end))
         dr_field = request.DATA.get("dr_field", getattr(cls.RestMeta, "DATE_RANGE_FIELD", "created"))
         q = dict()
@@ -1145,7 +1157,7 @@ class RestModel(object):
             cls._boundRest()
             if format.startswith("json"):
                 return GRAPH_HELPERS.views.restJSON(
-                    request, qset, fields, 
+                    request, qset, fields,
                     name, format_size, localize=localize)
             elif format.startswith("csv"):
                 return GRAPH_HELPERS.views.restCSV(
@@ -1159,7 +1171,7 @@ class RestModel(object):
                 return GRAPH_HELPERS.views.restFlat(
                     request, qset, fields,
                     name, format_size, localize=localize)
-    
+
     @classmethod
     def on_rest_list_summary(cls, request, qset):
         cls._boundRest()
@@ -1589,7 +1601,7 @@ class RestModel(object):
                 "group": "group__kind"
             }
 
-        QUERY_FIELDS can be used to restrict what fields can be queried 
+        QUERY_FIELDS can be used to restrict what fields can be queried
         and add special fields:
 
         ?group__kind=iso
@@ -1600,7 +1612,7 @@ class RestModel(object):
         or
         <field_name>__<operator>=value
 
-        You cannot do <field_name>__<sub_field>__<operator> unless 
+        You cannot do <field_name>__<sub_field>__<operator> unless
          <field_name>__<sub_field> is
 
         allowed <operator>s

{django_restit-4.2.173 → django_restit-4.2.174}/rest/requestex.py

@@ -18,12 +18,12 @@ SAFE_ASCII = set(string.printable)
 def createFakeRequest(method="GET", **kwargs):
     member = kwargs.get("member", objict(is_authenticated=True, is_staff=True, is_superuser=True))
     return objict(
-        META={}, 
+        META={},
         user=member,
         member=member,
         group=kwargs.get("group", None),
-        method=method, 
-        _started=0, 
+        method=method,
+        _started=0,
         DATA=RequestData(data=kwargs))
 
 
@@ -284,7 +284,6 @@ class RequestData(object):
             if value == '':
                 if field_type in [int, float]:
                     return field_type(0)
-
             if field_type in [int, str, float, str]:
                 value = field_type(value)
             elif field_type is datetime:

{django_restit-4.2.173 → django_restit-4.2.174}/rest/serializers/response.py

@@ -1,6 +1,8 @@
 from django.http import HttpResponse
 from django.shortcuts import render
 from django.db.models.query import QuerySet
+from django.core.cache import cache
+import hashlib
 
 from rest import settings
 from version import VERSION
@@ -13,6 +15,27 @@ from . import csv
 from . import excel
 # from . import profiler
 STATUS_ON_PERM_DENIED = settings.get("STATUS_ON_PERM_DENIED", 403)
+REST_LIST_CACHE_COUNT = settings.get("REST_LIST_CACHE_COUNT", True)
+
+
+def get_query_hash(queryset):
+    """Generate a unique hash based on the queryset's SQL query and params."""
+    sql_query = str(queryset.query)
+    return hashlib.sha256(sql_query.encode()).hexdigest()
+
+
+def get_cached_count(queryset, hash=None, timeout=1800):
+    """
+    Retrieves the cached count for a queryset or calculates & caches it.
+    """
+    if hash is None:
+        hash = get_query_hash(queryset)
+    cache_key = f"rest_hash_{hash}"
+    count = cache.get(cache_key)
+    if count is None:
+        count = queryset.count()
+        cache.set(cache_key, count, timeout=timeout)
+    return count
 
 
 def restStatus(request, status, data={}, **kwargs):
@@ -41,13 +64,20 @@ def restGet(request, obj, fields=None, extra=[], exclude=[], recurse_into=[], **
     data["elapsed"] = get_request_elapsed(request)
     return restResult(request, data)
 
+
 # @profiler.timeit
 def restList(request, qset, size=25, start=0, sort=None, fields=None, extra=[], exclude=[], recurse_into=[], **kwargs):
-    count = 0
-    if isinstance(qset, QuerySet):
-        count = qset.count()
-    elif isinstance(qset, list):
-        count = len(qset)
+    count = kwargs.get('count', 0)
+    hash = None
+    if count == 0:
+        if isinstance(qset, QuerySet):
+            if REST_LIST_CACHE_COUNT and not request.DATA.get("no_cache", False):
+                hash = get_query_hash(qset)
+                count = get_cached_count(qset, hash)
+            else:
+                count = qset.count()
+        elif isinstance(qset, list):
+            count = len(qset)
     start = request.DATA.get("start", start, field_type=int)
     size = request.DATA.get("size", size, field_type=int)
     sort = request.DATA.get("sort", sort)
@@ -56,6 +86,8 @@ def restList(request, qset, size=25, start=0, sort=None, fields=None, extra=[],
     data["datetime"] = int(time.time())
     data["elapsed"] = get_request_elapsed(request)
     data["count"] = count
+    if hash is not None:
+        data["hash"] = hash
     if "response_params" in kwargs:
         for k, v in kwargs.get("response_params").items():
             data[k] = v

django_restit-4.2.174/rest/service.py

@@ -0,0 +1,135 @@
+import os
+import signal
+import time
+import argparse
+import logging
+import daemon
+from daemon import pidfile
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+
+class Service(FileSystemEventHandler):
+    def __init__(self, name, pid_file, watch_file=None, require_user=None, logger=None):
+        self.name = name
+        self.pid_file = pid_file
+        self.watch_file = os.path.realpath(watch_file) if watch_file else None
+        self.require_user = require_user
+        self.observer = None
+
+    def log_info(self, *args):
+        if self.logger:
+            self.log_info(*args)
+
+    def start(self):
+        if self.is_running():
+            self.log_info("Service is already running.")
+            return
+
+        self.log_info(f"Starting {self.name}...")
+
+        with daemon.DaemonContext(
+            pidfile=pidfile.TimeoutPIDLockFile(self.pid_file),
+            stdout=open('/tmp/service.log', 'a+'),
+            stderr=open('/tmp/service_error.log', 'a+'),
+            signal_map={
+                signal.SIGTERM: self.stop,
+                signal.SIGHUP: self.restart
+            }
+        ):
+            self.run()
+
+    def stop(self, *args):
+        pid = self.get_pid()
+        if not pid:
+            self.log_info("Service is not running.")
+            return
+
+        self.log_info(f"Stopping {self.name} (PID: {pid})...")
+        try:
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(1)
+            if self.is_running():
+                os.kill(pid, signal.SIGKILL)
+            if os.path.exists(self.pid_file):
+                os.remove(self.pid_file)
+            self.log_info("Service stopped.")
+        except OSError:
+            self.logger.error(f"Failed to stop process {pid}")
+
+    def restart(self, *args):
+        self.log_info("Restarting service...")
+        self.stop()
+        time.sleep(1)
+        self.start()
+
+    def status(self):
+        if self.is_running():
+            print(f"{self.name} is running (PID: {self.get_pid()})")
+        else:
+            print(f"{self.name} is not running")
+
+    def is_running(self):
+        """Check if the process is running using os.kill(pid, 0)"""
+        pid = self.get_pid()
+        if pid:
+            try:
+                os.kill(pid, 0)  # Does not kill, just checks if process exists
+                return True
+            except OSError:
+                return False
+        return False
+
+    def get_pid(self):
+        if os.path.exists(self.pid_file):
+            try:
+                with open(self.pid_file, "r") as f:
+                    pid = int(f.read().strip())
+                return pid
+            except ValueError:
+                return None
+        return None
+
+    def run(self):
+        """Main daemon loop"""
+        self.log_info(f"{self.name} is running in background.")
+        if self.watch_file:
+            self.start_watcher()
+        self.on_run()
+
+    def on_run(self):
+        while True:
+            time.sleep(5)
+
+    def start_watcher(self):
+        self.log_info(f"Watching file: {self.watch_file}")
+        self.observer = Observer()
+        self.observer.schedule(self, path=os.path.dirname(self.watch_file), recursive=False)
+        self.observer.start()
+
+    def on_modified(self, event):
+        if self.watch_file and event.src_path == self.watch_file:
+            self.log_info("Config file changed, restarting service...")
+            self.restart()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Manage the service daemon")
+    parser.add_argument("command", choices=["start", "stop", "restart", "status", "run"])
+    args = parser.parse_args()
+
+    service = Service(name="MyDaemon", pid_file="/tmp/mydaemon.pid")
+
+    if args.command == "start":
+        service.start()
+    elif args.command == "stop":
+        service.stop()
+    elif args.command == "restart":
+        service.restart()
+    elif args.command == "status":
+        service.status()
+    elif args.command == "run":
+        service.run()
+
+if __name__ == "__main__":
+    main()

{django_restit-4.2.173 → django_restit-4.2.174}/rest/urls.py

@@ -63,7 +63,3 @@ for app in settings.INSTALLED_APPS:
             sub_modules = getattr(module, "RPC_MODULES")
             for m in sub_modules:
                 load_app(m, module)
-
-
-
-