django-restit 4.2.123__py3-none-any.whl → 4.2.125__py3-none-any.whl

{django_restit-4.2.123.dist-info → django_restit-4.2.125.dist-info}/METADATA

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

{django_restit-4.2.123.dist-info → django_restit-4.2.125.dist-info}/RECORD

@@ -91,7 +91,7 @@ inbox/models/message.py,sha256=acPm2z0QsucoFFmfzPekehElZm8EMzkcGChX_BpzGLU,3758
 inbox/models/template.py,sha256=i5vf0vsM1U0251UmVsF61MDCV_c7xt-zdCdx1SiKOG0,1013
 inbox/rpc.py,sha256=7JXvpXlEGKG7by_NkANPGYLCzagyCnTIGM4rme_htpk,1534
 inbox/utils/__init__.py,sha256=P_UR2rGK3L0tZNlTN-mf99tpeYM-tLkA18iDKXSSLDM,89
-inbox/utils/parsing.py,sha256=ae8JKm10qg6Q3dGhC29oDKKycN3yeDxI6e9SryPKxcY,4615
+inbox/utils/parsing.py,sha256=cU5qHaVNkje21b3ApeCixYQEuCsQl0gM8FeLz9DPgs0,5340
 inbox/utils/render.py,sha256=CU_F2qUBQE7mjb9Q6Dn9ro5CS_O_zEY-wDMHEClKkIA,4331
 inbox/utils/sending.py,sha256=BKelTZnbkdSLGpjOY6IRTrzj-Hnw2pPZ7RYQGwe-tqk,2179
 incident/README.md,sha256=4vbZTJj7uUmq8rogYngxqNYjFTlBOujfWUGheLoFKMc,1114
@@ -161,6 +161,7 @@ location/rpc/location.py,sha256=D5R54nnmmp8NaHQRkP_TF921Ej6j9nmTUNzX1K5WVPc,779
 location/rpc/track.py,sha256=jSS9_eiKayM_8iW_4Ldojg9a2_trjfXhnLe_a261x5E,3735
 medialib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 medialib/admin.py,sha256=befSpVP7TpyWGsh47E1CiFMUSwNYT7bxMgzgyDK07yI,2261
+medialib/caching.py,sha256=K5dE8fpsC2mpFB5WLJQKx9OtjuhvYeTtQM5vBA5IBEE,2292
 medialib/cvutil/__init__.py,sha256=ADxS2MfnLqzd7NI2QgWeQSNcgJCNBP2Wgy3hBZV9w4s,27
 medialib/cvutil/contours.py,sha256=B6_PGOIg_ORX9i3K8PE35H_c2H0LejLSRE1sQMxPaIc,4269
 medialib/cvutil/images.py,sha256=9qQDd1rE3HJZ0MBn2v39snBXatI9fLqYPQXgdCuaQs0,12649
@@ -272,6 +273,7 @@ medialib/stores/oauth2client/tools.py,sha256=OLSW5Iu7rtjGankFpjXlHBw8aAFOcIsWdDh
 medialib/stores/oauth2client/util.py,sha256=1Uc6qwqNhI3b507VtFnklX4sEZNt0MZbLAME2o6kCgg,5706
 medialib/stores/oauth2client/xsrfutil.py,sha256=4Plq0y5xEkDwvrveVA32gBRP0A3FkJ_36dIsyGHeJeA,3367
 medialib/stores/rtmpstore.py,sha256=CFRP6Ss4hbLKngbdaLvA8_oKCSe18B29-oWVgvTXMPA,500
+medialib/stores/s3.py,sha256=gAFiVHQkbYHZQ_2LU5nl2EXyoSs1mW4VdVCjsImisuE,5836
 medialib/stores/s3store.py,sha256=uKO6I-X83sD9xefCQytLyrV-7t9TSX2p476n_ZBkSHw,4583
 medialib/stores/uritemplate/__init__.py,sha256=ONWR_KRz9au0O-XUUTrO_UN7GHTmZCTKyvflUQb8wxM,4996
 medialib/stores/youtubestore.py,sha256=swXOJYfbhgzAv1NjOehjKtfYRZYk2wiPK7a7_boAulc,406
@@ -374,7 +376,7 @@ pushit/utils.py,sha256=IeTCGa-164nmB1jIsK1lu1O1QzUhS3BKfuXHGjCW-ck,2121
 rest/.gitignore,sha256=TbEvWRMnAiajCTOdhiNrd9eeCAaIjRp9PRjE_VkMM5g,118
 rest/README.md,sha256=V3ETc-cJu8PZIbKr9xSe_pA4JEUpC8Dhw4bQeVCDJPw,5460
 rest/RemoteEvents.py,sha256=nL46U7AuxIrlw2JunphR1tsXyqi-ep_gD9CYGpYbNgE,72
-rest/__init__.py,sha256=9U4bbRpojdF2iTaNZzy6i2wcFFL4PyJAXf243H2cR_w,122
+rest/__init__.py,sha256=NBdgyzD7Sr_EusbqnuFbRRRqTOZ83u4uzw9o1hGOOnw,122
 rest/arc4.py,sha256=y644IbF1ec--e4cUJ3KEYsewTCITK0gmlwa5mJruFC0,1967
 rest/cache.py,sha256=1Qg0rkaCJCaVP0-l5hZg2CIblTdeBSlj_0fP6vlKUpU,83
 rest/crypto/__init__.py,sha256=Tl0U11rgj1eBYqd6OXJ2_XSdNLumW_JkBZnaJqI6Ldw,72
@@ -509,7 +511,7 @@ ws4redis/servers/uwsgi.py,sha256=VyhoCI1DnVFqBiJYHoxqn5Idlf6uJPHvfBKgkjs34mo,172
 ws4redis/settings.py,sha256=K0yBiLUuY81iDM4Yr-k8hbvjn5VVHu5zQhmMK8Dtz0s,1536
 ws4redis/utf8validator.py,sha256=S0OlfjeGRP75aO6CzZsF4oTjRQAgR17OWE9rgZdMBZA,5122
 ws4redis/websocket.py,sha256=R0TUyPsoVRD7Y_oU7w2I6NL4fPwiz5Vl94-fUkZgLHA,14848
-django_restit-4.2.123.dist-info/LICENSE.md,sha256=VHN4hhEeVOoFjtG-5fVv4jesA4SWi0Z-KgOzzN6a1ps,1068
-django_restit-4.2.123.dist-info/METADATA,sha256=HGtIB4-fKEK2kSVmhVJ0a3uo7qH0DTy1r_P1xskGYG4,7663
-django_restit-4.2.123.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-django_restit-4.2.123.dist-info/RECORD,,
+django_restit-4.2.125.dist-info/LICENSE.md,sha256=VHN4hhEeVOoFjtG-5fVv4jesA4SWi0Z-KgOzzN6a1ps,1068
+django_restit-4.2.125.dist-info/METADATA,sha256=1MGxqma8EG_Bsb6xAzGNoEcvCsFIOwCbnkUjFh3SNQY,7663
+django_restit-4.2.125.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+django_restit-4.2.125.dist-info/RECORD,,

inbox/utils/parsing.py

@@ -1,5 +1,7 @@
 from io import StringIO
 import email
+import re
+
 from email.utils import parseaddr, parsedate_to_datetime, getaddresses
 from email.header import decode_header
 
@@ -129,6 +131,24 @@ def toFileObject(attachment):
     return obj
 
 
+def parseAddresses(input_string):
+    # Define a regex pattern to capture email addresses
+    email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
+    # Find all matches of the pattern in the input string
+    emails = re.findall(email_pattern, input_string)
+    # Create a list to hold parsed email data
+    parsed_emails = []
+    for addr in emails:
+        # Extract name if it exists
+        name_match = re.search(r'([a-zA-Z\s]+)?\s*<{}>'.format(re.escape(addr)), input_string)
+        if name_match and name_match.group(1):
+            name = name_match.group(1).strip()
+        else:
+            name = None
+        parsed_emails.append(objict(name=name, email=addr))
+    return parsed_emails
+
+
 def toString(value):
     if isinstance(value, bytes):
         value = value.decode()

medialib/caching.py

@@ -0,0 +1,63 @@
+from rest import settings
+from medialib.stores import s3
+from django.http import HttpResponse, StreamingHttpResponse
+from datetime import datetime
+AWS_CACHING_BUCKET = settings.get("AWS_CACHING_BUCKET", settings.AWS_S3_BUCKET)
+
+
+def on_cached_rest_list(Model, request):
+    cache_guid = request.DATA.get("format_filename")
+    file_format = request.DATA.get("format", None)
+    if not file_format:
+        file_format = "csv"
+        request.DATA.set("format", file_format)
+    content_type = "text/csv"
+    if file_format[:3] == "csv":
+        file_format = "csv"
+    else:
+        file_format = "json"
+        content_type = "application/json"
+    if cache_guid:
+        resp = getCachedResponse(cache_guid)
+        if resp is not None:
+            return resp
+        resp = Model.on_rest_list(request)
+        # TODO only cache if dr_end exists and is less then today
+        dr_end = request.DATA.get("dr_end", field_type=datetime)
+        if dr_end < datetime.now():
+            cacheResponse(resp, cache_guid, content_type=content_type)
+        return resp
+    return Model.on_rest_list(request)
+
+
+def getCachedResponse(cache_guid, content_type="application/json"):
+    item = getCachedItem(cache_guid, content_type)
+    if not item.exists:
+        return None
+    return _createResponse(item, cache_guid)
+
+
+def getCachedItem(cache_guid, content_type="application/json"):
+    url = f"s3://{settings.AWS_S3_BUCKET}/caching/{cache_guid}"
+    return s3.S3Item(url, content_type)
+
+
+def cacheResponse(response, cache_guid, content_type="application/json"):
+    url = f"s3://{settings.AWS_S3_BUCKET}/caching/{cache_guid}"
+    item = s3.S3Item(url, content_type)
+    item.upload(response.content)
+    return item
+
+
+def _createResponse(item, cache_guid):
+    # Create a StreamingHttpResponse object with the file iterator
+    fp = item.download()
+    fp.seek(0)
+    fp.name = cache_guid
+    response = StreamingHttpResponse(fp)
+    # Add the appropriate content type header to the response
+    # You might want to dynamically determine the content type based on the file
+    response['Content-Type'] = item.content_type
+    # Set the Content-Disposition header to prompt download with a filename
+    response['Content-Disposition'] = f'attachment; filename="{cache_guid}"'
+    return response

medialib/stores/s3.py

@@ -0,0 +1,208 @@
+from rest import settings
+from objict import objict
+# import boto
+# from boto.s3.connection import S3Connection
+import boto3
+import botocore
+
+from urllib.parse import urlparse
+import io
+import sys
+from medialib import utils
+import threading
+import tempfile
+
+S3 = objict(KEY=settings.AWS_KEY, SECRET=settings.AWS_SECRET, BUCKET=settings.AWS_S3_BUCKET)
+
+
+class S3Item(object):
+    def __init__(self, url, content_type="application/json", metadata=None):
+        self.url = url
+        u = urlparse(url)
+        self.bucket_name = u.netloc
+        self.key = u.path.lstrip('/')
+        self.content_type = content_type
+        self.s3 = getS3()
+        self.host = "https://s3.amazonaws.com"
+        self.metadata = metadata
+        self.object = getObject(self.bucket_name, self.key)
+        self.exists = self.checkExists()
+
+    def checkExists(self):
+        try:
+            self.object.load()
+        except botocore.exceptions.ClientError as e:
+            if e.response['Error']['Code'] == "404":
+                # The object does not exist.
+                return False
+            else:
+                # Something else has gone wrong.
+                raise
+        return True
+
+    def upload(self, fp, background=False):
+        if self.metadata:
+            return self.object.upload_fileobj(openFile(fp), ExtraArgs=self.metadata)
+        self.object.upload_fileobj(openFile(fp))
+
+    def createUpload(self):
+        self.part_num = 0
+        self.parts = []
+        self.client = getS3(False)
+        resp = self.client.create_multipart_upload(Bucket=self.bucket_name, Key=self.key)
+        self.upload_id = resp["UploadId"]
+        return True
+
+    def uploadPart(self, chunk):
+        self.part_num += 1
+        resp = self.client.upload_part(
+            Bucket=self.bucket_name,
+            Key=self.key,
+            PartNumber=self.part_num,
+            UploadId=self.upload_id,
+            Body=chunk)
+        self.parts.append(dict(PartNumber=self.part_num, ETag=resp["ETag"]))
+
+    def completeUpload(self):
+        resp = self.client.complete_multipart_upload(
+            Bucket=self.bucket_name,
+            Key=self.key,
+            UploadId=self.upload_id,
+            MultipartUpload=dict(Parts=self.parts))
+        return resp
+
+    @property
+    def public_url(self):
+        return "{}/{}/{}".format(self.host, self.bucket_name, self.key)
+
+    def generateURL(self, expires=600):
+        client = getS3(False)
+        return client.generate_presigned_url(
+            'get_object',
+            ExpiresIn=expires,
+            Params={'Bucket': self.bucket_name, 'Key': self.key})
+
+    def download(self, fp=None):
+        if fp is None:
+            fp = tempfile.NamedTemporaryFile()
+        self.object.download_fileobj(fp)
+        return fp
+
+    def delete(self):
+        self.object.delete()
+
+
+def _getS3(as_resource=True, key=S3.KEY, secret=S3.SECRET):
+    if as_resource:
+        return boto3.resource('s3', aws_access_key_id=key, aws_secret_access_key=secret)
+    return boto3.client('s3', aws_access_key_id=key, aws_secret_access_key=secret)
+
+
+def getS3(as_resource=True):
+    if as_resource:
+        if S3.resource is None:
+            S3.resource = _getS3(True)
+        return S3.resource
+    if S3.client is None:
+        S3.client = _getS3(False)
+    return S3.client
+
+
+def getBucket(name):
+    s3r = getS3()
+    return s3r.Bucket(name)
+
+
+def getObject(bucket_name, key):
+    s3r = getS3()
+    return s3r.Object(bucket_name, key)
+
+
+def getObjectContent(bucket_name, key):
+    s3r = getS3(False)
+    obj = s3r.get_object(Bucket=bucket_name, Key=key)
+    return obj['Body'].read().decode('utf-8')
+
+
+class ProgressPercentage(object):
+    def __init__(self, size):
+        self._size = size
+        self._seen_so_far = 0
+        self._lock = threading.Lock()
+
+    def __call__(self, bytes_amount):
+        # To simplify we'll assume this is hooked up
+        # to a single filename.
+        with self._lock:
+            self._seen_so_far += bytes_amount
+            percentage = (self._seen_so_far / self._size) * 100
+            sys.stdout.write(
+                "\r%s  %s / %s  (%.2f%%)" % (
+                    self._filename, self._seen_so_far, self._size,
+                    percentage))
+            sys.stdout.flush()
+
+
+def upload(url, fp, background=False):
+    obj = S3Item(url)
+    obj.upload(fp)
+
+
+def view_url_noexpire(url, is_secure=False):
+    obj = S3Item(url)
+    return obj.public_url
+
+
+def view_url(url, expires=600, is_secure=True):
+    if expires is None:
+        return view_url_noexpire(url, is_secure)
+    obj = S3Item(url)
+    return obj.generateURL(expires)
+
+
+def exists(url):
+    obj = S3Item(url)
+    return obj.exists
+
+
+def get_file(url, fp=None):
+    obj = S3Item(url)
+    return obj.download(fp)
+
+
+def delete(url):
+    if url[-1] == "/":
+        prefix = url.path.lstrip("/")
+        bucket_name = url.netloc
+        s3 = getS3()
+        response = s3.list_objects_v2(
+            Bucket=bucket_name,
+            Prefix =prefix,
+            MaxKeys=100)
+        for obj in response['Contents']:
+            s3.delete_object(Bucket=bucket_name, Key=object['Key'])
+    else:
+        obj = S3Item(url)
+        obj.delete()
+        # _getkey(url, key=settings.AWS_ADMIN_KEY, secret=settings.AWS_ADMIN_SECRET).delete()
+
+
+def openFile(fp):
+    # this should fail if already opened.. if not iwll open
+    # even if wrapped file-like object exists. To avoid Django-specific
+    # logic, pass a copy of internal file-like object if `content` is
+    # `File` class instance.
+    if isinstance(fp, (str, bytes)):
+        return io.BytesIO(utils.toBytes(fp))
+    if hasattr(fp, "read"):
+        return io.BytesIO(utils.toBytes(fp.read()))
+    try:
+        return open(fp.name, "r")
+    except IOError:
+        pass
+    return fp
+
+
+def path(url):
+    u = urlparse(url)
+    return u.path

rest/__init__.py

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