django-restit 4.2.85__tar.gz → 4.2.87__tar.gz

{django_restit-4.2.85 → django_restit-4.2.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-restit
-Version: 4.2.85
+Version: 4.2.87
 Summary: A Rest Framework for DJANGO
 License: MIT
 Author: Ian Starnes

{django_restit-4.2.85 → django_restit-4.2.87}/account/models/member.py

@@ -554,11 +554,11 @@ class Member(User, RestModel, MetaDataModel):
         if auth_session is not None and auth_session.location is not None:
             try:
                 if auth_session.location.country != loc.country:
-                    details = f"user login from new country {loc.country} vs previous {auth_session.location.country}"
-                    self.reportIncident("account", details)
+                    details = f"user({self.username}) login from new country {loc.country} vs previous {auth_session.location.country}"
+                    self.reportIncident("account", details, details=details, error_code=491)
                 elif auth_session.location.state != loc.state:
-                    details = f"user login from new state {loc.state} vs previous {auth_session.location.state}"
-                    self.reportIncident("account", details)
+                    details = f"user({self.username}) login from new state {loc.state} vs previous {auth_session.location.state}"
+                    self.reportIncident("account", details, details=details, error_code=491)
             except Exception:
                 rh.log_exception(self.username)
 

{django_restit-4.2.85 → django_restit-4.2.87}/location/rpc/ip.py

@@ -27,11 +27,16 @@ def on_ip_lookup(request):
 
 @rd.urlGET('geo/ip')
 @rd.urlGET('geo/ip/<int:pk>')
-@rd.login_required
 def rest_on_geoip(request, pk=None):
     return location.GeoIP.on_rest_request(request, pk)
 
 
+@rd.urlPOST('geo/ip/<int:pk>')
+@rd.perm_required(["manage_location"])
+def rest_save_geoip(request, pk=None):
+    return location.GeoIP.on_rest_request(request, pk)
+
+
 @rd.urlPOST('geo/ip')
 @rd.login_required
 @rd.requires_params(["ip"])

{django_restit-4.2.85 → django_restit-4.2.87}/metrics/client.py

@@ -38,8 +38,10 @@ def set_metric(slug, value, category=None, expire=None, date=None):
     get_r().set_metric(slug, value, category=category, expire=expire, date=date)
 
 
-def get_metric(slug, min_granularity=None, max_granularity=None):
+def get_metric(slug, min_granularity=None, max_granularity=None, category=None):
     """get a metric."""
+    if category is not None:
+        return get_r().get_metric_by_category(category, min_granularity, max_granularity)
     return get_r().get_metric(slug, min_granularity, max_granularity)
 
 
@@ -52,7 +54,7 @@ def get_metrics(slugs, since=None, granularity="daily", group=None, samples=None
 def get_category_metrics(category, since=None, granularity="daily", samples=None):
     """Create/Increment a metric."""
     r = get_r()
-    slugs = [utils.to_string(s) for s in list(r.category_slugs(category))]
+    slugs = r.category_slugs(category, True)
     return r.get_metric_history_chart_data(
         slugs, since, granularity, samples=samples)
 
@@ -60,8 +62,10 @@ def get_category_metrics(category, since=None, granularity="daily", samples=None
 def get_slugs(category=None):
     """get slug list"""
     if category:
-        return list(get_r().category_slugs(category))
-    return list(get_r().metric_slugs())
+        slugs = list(get_r().category_slugs(category))
+    else:
+        slugs = list(get_r().metric_slugs())
+    return [utils.to_string(s) for s in list(slugs)]
 
 
 def get_gauge(slug):
@@ -173,10 +177,12 @@ class R(object):
     def _category_key(self, category):
         return u"c:{0}".format(category)
 
-    def category_slugs(self, category):
+    def category_slugs(self, category, as_string=False):
         """Returns a set of the metric slugs for the given category"""
         key = self._category_key(category)
         slugs = self.r.smembers(key)
+        if as_string:
+            return [utils.to_string(s) for s in slugs]
         return slugs
 
     def _categorize(self, slug, category):
@@ -210,7 +216,7 @@ class R(object):
         result = utils.OrderedDict()
         categories = sorted(self.r.smembers(self._categories_key))
         for category in categories:
-            result[category] = self.category_slugs(category)
+            result[category] = self.category_slugs(category, True)
 
         # We also need to see the uncategorized metric slugs, so need some way
         # to check which slugs are not already stored.
@@ -354,6 +360,12 @@ class R(object):
                     pipe.expireat(key, d_expireat)
         pipe.execute()
 
+    def get_metric_by_category(self, category, min_granularity=None, max_granularity=None):
+        results = UberDict()
+        for slug in self.category_slugs(category, True):
+            results[slug] = self.get_metric(slug, min_granularity, max_granularity)
+        return results
+
     def get_metric(self, slug, min_granularity=None, max_granularity=None):
         """Get the current values for a metric.
 
@@ -363,12 +375,17 @@ class R(object):
         """
         results = UberDict()
         granularities = utils.granularities(min_granularity, max_granularity)
-        keys = utils.build_keys(slug)
+        keys = utils.build_keys(slug, min_granularity=min_granularity, max_granularity=max_granularity)
+
         for granularity, key in zip(granularities, keys):
+            rh.debug("-- get_metric --", granularity, key)
             try:
                 results[granularity] = int(self.r.get(key))
             except Exception:
-                pass
+                results[granularity] = 0
+                rh.log_exception("get_metric", granularity, key)
+        if min_granularity and min_granularity == max_granularity:
+            return results[min_granularity]
         return results
 
     def get_metrics(self, slug_list):
@@ -401,8 +418,9 @@ class R(object):
 
     def get_category_metrics(self, category):
         """Get metrics belonging to the given category"""
-        slug_list = self.category_slugs(category)
-        return self.get_metrics(slug_list)
+        slug_list = self.category_slugs(category, True)
+        res = self.get_metrics(slug_list)
+        return res
 
     def delete_category(self, category):
         """Removes the category from Redis. This doesn't touch the metrics;
@@ -571,7 +589,7 @@ class R(object):
             since = date_util.convertToLocalTime(settings.METRICS_TIMEZONE, since)
 
         slugs = sorted(slugs)
-        rh.debug(f"get_metric_history {since}")
+        # rh.debug(f"get_metric_history {since}", slugs)
         history = self.get_metric_history(slugs, since, granularity=granularity)
 
         # Convert the history into an intermediate data structure organized

{django_restit-4.2.85 → django_restit-4.2.87}/metrics/rpc.py

@@ -48,14 +48,29 @@ def rest_on_new_metric(request):
 def rest_on_get_metric(request):
     # slug, num=1, category=None, expire=None, date=None
     data = request.DATA.toObject()
-    if data.slug is None:
+    if data.slug is None and data.category is None:
         return rv.restStatus(request, False)
-    result = metrics.get_metric(data.slug)
+    if data.granularity:
+        data.min_granularity = data.granularity
+        data.max_granularity = data.granularity
+    result = metrics.get_metric(
+        data.slug, category=data.category,
+        min_granularity=data.min_granularity,
+        max_granularity=data.max_granularity)
     if result is None:
         return rv.restStatus(request, False)
+    if data.prefix:
+        result = {key[len(data.prefix):]:value for key, value in result.items()}
     return rv.restReturn(request, dict(data=result))
 
 
+def truncatePrefix(prefix, data):
+    # rh.debug("prefix", prefix, data)
+    for values in data["data"]:
+        if values["slug"].startswith(prefix):
+            values["slug"] = values["slug"][len(prefix):]
+
+
 @rd.urlGET('metrics')
 @rd.login_required
 def rest_on_get_metrics(request, pk=None):
@@ -64,9 +79,12 @@ def rest_on_get_metrics(request, pk=None):
     granularity = request.DATA.get(["granularity", "period"], default="daily")
     samples = request.DATA.get("samples", field_type=int)
     category = request.DATA.get("category")
-    rh.debug(f"rest_on_get_metrics: {since}, {granularity}, {samples}, {category}")
+    prefix = request.DATA.get("prefix")
+    # rh.debug(f"rest_on_get_metrics: {since}, {granularity}, {samples}, {category}")
     if category:
         result = metrics.get_category_metrics(category, since, granularity, samples=samples)
+        if prefix:
+            truncatePrefix(prefix, result)
         return rv.restReturn(request, dict(data=result))
     slugs = request.DATA.getlist(["slugs", "slug"])
     if slugs is None:
@@ -75,6 +93,8 @@ def rest_on_get_metrics(request, pk=None):
     result = metrics.get_metrics(slugs, since, granularity, samples=samples)
     if result is None:
         return rv.restStatus(request, False)
+    if prefix:
+        truncatePrefix(prefix, result)
     return rv.restReturn(request, dict(data=result))
 
 

{django_restit-4.2.85 → django_restit-4.2.87}/metrics/utils.py

@@ -90,21 +90,36 @@ def metric_slug(value):
 def granularities(min_granularity=None, max_granularity=None):
     """Returns a generator of all possible granularities based on the
     MIN_GRANULARITY and MAX_GRANULARITY settings.
+    
+    Args:
+        min_granularity (str): Optional; the minimum granularity to include.
+        max_granularity (str): Optional; the maximum granularity to include.
+        
+    Yields:
+        str: A granularity level from the predefined list of granularities.
     """
+    # Use default settings if no values are provided
     if min_granularity is None:
         min_granularity = app_settings.MIN_GRANULARITY
     if max_granularity is None:
         max_granularity = app_settings.MAX_GRANULARITY
-    keep = False
+
+    # Initialize a flag to determine when to start yielding granularities
+    start_yielding = False
+
+    # Loop through each granularity in the list of all granularities
     for g in GRANULARITIES:
-        if g == min_granularity and not keep:
-            keep = True
-        elif g == max_granularity and keep:
-            keep = False
-        if keep:
-            if g == max_granularity:
-                keep = False
+        # Start yielding when the minimum granularity is reached
+        if g == min_granularity:
+            start_yielding = True
+        
+        # Yield the current granularity if the flag is true
+        if start_yielding:
             yield g
+        
+        # Stop yielding after the maximum granularity has been yielded
+        if g == max_granularity:
+            break
 
 
 def get_metric_key_pattern(granularity, slug, date):

{django_restit-4.2.85 → django_restit-4.2.87}/pyproject.toml

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

{django_restit-4.2.85 → django_restit-4.2.87}/rest/helpers.py

@@ -6,9 +6,9 @@ from .settings_helper import settings
 import importlib
 from django.db.models import Count, Q, Avg, Sum, Max, Min
 from django.db.models.query import QuerySet
+# from django.db.models.functions import TruncWeek, TruncMonth, TruncYear
 from io import StringIO
 import base64
-import binascii
 
 from objict import objict
 from .datem import *
@@ -518,24 +518,28 @@ def filterByDates(qset, start=None, end=None, date_field="created"):
         return qset.filter(**q)
     return qset
 
+
 def getAverage(qset, field_name):
     res = qset.aggregate(avg_result=Avg(field_name))
     if "avg_result" in res and res["avg_result"] != None:
         return res["avg_result"]
     return 0.0
 
+
 def getMin(qset, field_name):
     res = qset.aggregate(min_result=Min(field_name))
     if "min_result" in res and res["min_result"] != None:
         return res["min_result"]
     return 0.0
 
+
 def getMax(qset, field_name):
     res = qset.aggregate(max_result=Max(field_name))
     if "max_result" in res and res["max_result"] != None:
         return res["max_result"]
     return 0.0
 
+
 def getSum(qset, *args):
     params = {}
     for field_name in args:
@@ -555,6 +559,33 @@ def getSum(qset, *args):
     return results
 
 
+def getGroupLeaders(Model, timeframe="week", date_field="created", 
+                    size=10, field="id", action="count", out_field="value"):
+    today = datetime.now()
+    # FIXME: yes timerange to deal with timezone issues
+    q = {f"{date_field}__year": today.year}
+    if timeframe == "week":
+        q[f"{date_field}__week"] = today.isocalendar()[1]
+    elif timeframe == "month":
+        q[f"{date_field}__month"] = today.month
+    elif timeframe == "day":
+        q[f"{date_field}__day"] = today.day
+    qset = Model.objects.filter(**q).values('group__name', 'group')
+    if field == "id":
+        return list(qset.annotate(value=Count('id')).order_by('-value')[:size])
+    field_key = f"{field}_{action}"
+    if out_field:
+        field_key = out_field
+    aq = {}
+    if action == "sum":
+        aq[field_key] = Sum(field)
+    elif action == "average":
+        aq[field_key] = Avg(field)
+    else:
+        aq[field_key] = Count(field)
+    return list(qset.annotate(**aq).order_by(f"-{field_key}")[:size])
+
+
 def countOccurences(qset, field_name):
     output = objict()
     for item in list(qset.values(field_name).annotate(count=Count(field_name))):