From 386cafe0dde0d0c370c07cf572a1c8405bf8760e Mon Sep 17 00:00:00 2001
From: Ari Brown <ari@airintech.com>
Date: Wed, 2 Aug 2023 14:51:47 -0400
Subject: [PATCH] dropped pycache files, renaming others

---
 minerva/__init__.py                           |   6 +-
 minerva/__pycache__/__init__.cpython-310.pyc  | Bin 148 -> 0 bytes
 minerva/__pycache__/blueshift.cpython-310.pyc | Bin 3533 -> 0 bytes
 minerva/__pycache__/minerva.cpython-310.pyc   | Bin 3338 -> 0 bytes
 minerva/{minerva.py => athena.py}             |  96 ++++++---------
 minerva/parallel.py                           |  21 ++++
 minerva/redshift.py                           | 114 ++++++++++++++++++
 minerva/s3.py                                 |   0
 pyproject.toml                                |   3 +-
 test.py                                       |   4 +-
 test2.py                                      |   8 +-
 11 files changed, 184 insertions(+), 68 deletions(-)
 delete mode 100644 minerva/__pycache__/__init__.cpython-310.pyc
 delete mode 100644 minerva/__pycache__/blueshift.cpython-310.pyc
 delete mode 100644 minerva/__pycache__/minerva.cpython-310.pyc
 rename minerva/{minerva.py => athena.py} (50%)
 create mode 100644 minerva/parallel.py
 create mode 100644 minerva/redshift.py
 create mode 100644 minerva/s3.py

diff --git a/minerva/__init__.py b/minerva/__init__.py
index 1b2a66f..d9b4770 100644
--- a/minerva/__init__.py
+++ b/minerva/__init__.py
@@ -1,7 +1,9 @@
-from .minerva import Athena, Execute, Query
+from .minerva import Athena, Execute, Query, Redshift, parallel_map
 
 __all__ = [
     "Execute",
     "Query",
-    "Athena"
+    "Athena",
+    "Redshift",
+    "parallel_map"
 ]
diff --git a/minerva/__pycache__/__init__.cpython-310.pyc b/minerva/__pycache__/__init__.cpython-310.pyc
deleted file mode 100644
index 2edd91a63bdc5abdf254efcd5b65ffca3ce43300..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 148
zcmd1j<>g`kf`8U0Q$X}%5P=LBfgA@QE@lA|DGb33nv8xc8Hzx{2;!HyerR!OQL%nv
zQKo)*eo?l5Mq*`gNn)~oaZ$2<Zf0I;QCT9Kj*rjG%PfhH*DI*J#bJ}1pHiBWY6mi~
Km<dR*FaQ870U|sA

diff --git a/minerva/__pycache__/blueshift.cpython-310.pyc b/minerva/__pycache__/blueshift.cpython-310.pyc
deleted file mode 100644
index 3bddbfcd1a7211724864fcebc7f81ec055519095..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3533
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
Tu}K>i5H0|0WkuA)`s@D#Awln|

diff --git a/minerva/__pycache__/minerva.cpython-310.pyc b/minerva/__pycache__/minerva.cpython-310.pyc
deleted file mode 100644
index 8beeb5077068e9e0b6f1c03ef4b310e8a3e67306..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3338
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

diff --git a/minerva/minerva.py b/minerva/athena.py
similarity index 50%
rename from minerva/minerva.py
rename to minerva/athena.py
index da0ba0e..9c423d2 100644
--- a/minerva/minerva.py
+++ b/minerva/athena.py
@@ -6,6 +6,7 @@ import pyarrow as pa
 import pyarrow.dataset
 import pprint
 import datetime
+from minerva import parallel_map
 
 pp = pprint.PrettyPrinter(indent=4)
 
@@ -19,7 +20,7 @@ class Athena:
         q = Query(self, sql)
         q.run()
         return q
-    
+
     def execute(self, sql):
         e = Execute(self, sql)
         e.run()
@@ -42,13 +43,13 @@ class Execute:
         self.handler = handler
         self.athena  = handler.athena
         self.sql     = sql
+        self.info_cache = None
+
+    def query(self):
+        return self.sql
 
     def run(self):
-        out    = os.path.join(self.handler.output,
-                              str(random.random()))
-        config = {"OutputLocation": out}
-        resp  = self.athena.start_query_execution(QueryString=self.sql,
-                                                  ResultConfiguration=config)
+        resp  = self.athena.start_query_execution(QueryString=self.sql)
         self.query_id = resp['QueryExecutionId']
         return resp
 
@@ -57,75 +58,52 @@ class Execute:
 
     def info(self):
         res = self.athena.get_query_execution(QueryExecutionId=self.query_id)
-        return res['QueryExecution']
+        self.info_cache = res['QueryExecution']
+        return self.info_cache
 
-    def execute(self):
-        tiedot = self.info()
-        status = tiedot['Status']['State']
-
-        while status in ['QUEUED', 'RUNNING']:
+    def finish(self):
+        while stat := self.status() in ['QUEUED', 'RUNNING']:
             time.sleep(5)
-            tiedot = self.info()
-            status = tiedot['Status']['State']
 
-        return status # finalized state
+        return stat # finalized state
 
 
-class Query:
+class Query(Execute):
     DATA_STYLE = 'parquet'
 
-    def __init__(self, handler, sql):
-        self.handler = handler
-        self.athena  = handler.athena
-        self.sql     = sql
-
-    def run(self):
+    def query(self):
         out    = os.path.join(self.handler.output,
                               str(random.random()))
-        config = {"OutputLocation": out}
         query  = f"unload ({self.sql}) to {repr(out)} " + \
                  f"with (format = '{self.DATA_STYLE}')"
+        return query
 
-        resp  = self.athena.start_query_execution(QueryString=query,
-                                                  ResultConfiguration=config)
-        self.query_id = resp['QueryExecutionId']
-        return resp
-
-    def status(self):
-        return self.info()['Status']
-
-    def info(self):
-        res = self.athena.get_query_execution(QueryExecutionId=self.query_id)
-        return res['QueryExecution']
-
-    def results(self):
-        tiedot = self.info()
-        status = tiedot['Status']['State']
-
-        while status in ['QUEUED', 'RUNNING']:
-            time.sleep(5)
-            tiedot = self.info()
-            status = tiedot['Status']['State']
+    def manifest_files(self):
+        status = self.finish()
 
         if status == "SUCCEEDED":
-            # Because we're using `UNLOAD`, we get a manifest of the files
-            # that make up our data.
-            files   = self.manifest(tiedot).strip().split("\n")
-            files   = [f.strip() for f in files if f.strip()] # filter empty
-
-            # TODO parallelize this
-            local   = [self.handler.download(f) for f in files]
-            self.ds = pa.dataset.dataset(local)
-
-            ms = tiedot['Statistics']['TotalExecutionTimeInMillis']
+            # Track the runtime
+            ms = self.info_cache['Statistics']['TotalExecutionTimeInMillis']
             self.runtime = datetime.timedelta(seconds=ms / 1000)
 
-            return self.ds
+            # Because we're using `UNLOAD`, we get a manifest of the files
+            # that make up our data.
+            manif = self.info_cache['Statistics']['DataManifestLocation']
+            tmp   = self.handler.download(manif)
+            with open(tmp, "r") as f:
+                txt = f.read()
+
+            files = txt.strip().split("\n")
+            files = [f.strip() for f in files if f.strip()] # filter empty
+
+            return files
         else:
             return status # canceled or error
 
-    def manifest(self, tiedot):
-        manif = tiedot['Statistics']['DataManifestLocation']
-        tmp   = self.handler.download(manif)
-        with open(tmp, "r") as f:
-            return f.read()
+    # TODO parallelize this
+    def results(self):
+        #local   = [self.handler.download(f) for f in self.manifest_files()]
+        local   = parallel_map(self.handler.download, self.manifest_files())
+        self.ds = pa.dataset.dataset(local)
+        return self.ds
+
diff --git a/minerva/parallel.py b/minerva/parallel.py
new file mode 100644
index 0000000..fd44c7f
--- /dev/null
+++ b/minerva/parallel.py
@@ -0,0 +1,21 @@
+from joblib import Parallel, delayed
+
+# Instead of taking each object in the list and giving it its own thread,
+# this splits the list into `cores` groups and gives each group its own
+# thread, where the group is now processed in series within its thread.
+#
+# Example:
+#   def say(stuff):
+#       print(stuff)
+#
+#   parallel_map(say, [str(i) for i in range(10)], cores=4)
+def parallel_map(func=None, data=None, cores=8):
+    size = len(data) // cores
+    groups = [data[i:i + size] for i in range(0, len(data), size)]
+
+    def wrapper_func(fs):
+        return [func(f) for f in fs]
+
+    res = Parallel(n_jobs=cores)(delayed(wrapper_func)(group) for group in groups)
+
+    return [val for r in res for val in r]
diff --git a/minerva/redshift.py b/minerva/redshift.py
new file mode 100644
index 0000000..f7cf971
--- /dev/null
+++ b/minerva/redshift.py
@@ -0,0 +1,114 @@
+import boto3
+import os
+import random
+import time
+import pyarrow as pa
+import pyarrow.dataset
+import pprint
+import datetime
+from minerva import parallel_map
+
+pp = pprint.PrettyPrinter(indent=4)
+
+class Redshift:
+    def __init__(self, profile, output, db=None, cluster=None):
+        self.session  = boto3.session.Session(profile_name=profile)
+        self.redshift = self.session.client("redshift-data")
+        self.output   = output
+        self.database = db
+        self.cluster  = cluster
+
+    def query(self, sql):
+        q = Query(self, sql)
+        q.run()
+        return q
+
+    def execute(self, sql):
+        e = Execute(self, sql)
+        e.run()
+        return e
+
+    def download(self, s3):
+        bucket = s3.split("/")[2]
+        file   = os.path.join(*s3.split("/")[3:])
+        tmp    = f"/tmp/{random.random()}.bin"
+        self.session.client('s3').download_file(bucket, file, tmp)
+
+        return tmp
+
+class Execute:
+    """
+    Execute will not return results, but will execute the SQL and return the final state.
+    Execute is meant to be used for DML statements such as CREATE DATABASE/TABLE
+    """
+    def __init__(self, handler, sql):
+        self.handler    = handler
+        self.redshift   = handler.redshift
+        self.sql        = sql
+        self.info_cache = None
+
+    def query(self):
+        return self.sql
+
+    def run(self):
+        resp  = self.redshift.execute_statement(Sql=self.query(),
+                                                Database=self.handler.database,
+                                                ClusterIdentifier=self.handler.cluster)
+        self.query_id = resp['Id']
+        return resp
+
+    def status(self):
+        return self.info()['Status']
+
+    def info(self):
+        res = self.redshift.describe_statement(Id=self.query_id)
+        self.info_cache = res
+        return self.info_cache
+
+    def finish(self):
+        while stat := self.status() in ['SUBMITTED', 'PICKED', 'STARTED']:
+            time.sleep(5)
+
+        return stat # finalized state
+
+
+class Query(Execute):
+    DATA_STYLE = 'parquet'
+
+    def query(self):
+        self.out = os.path.join(self.handler.output,
+                              str(random.random()))
+        query    = f"unload ({repr(self.sql)}) to {repr(self.out)} " + \
+                   f"iam_role default " + \
+                   f"format as {self.DATA_STYLE} " + \
+                   f"manifest"
+        return query
+
+    def manifest_files(self):
+        status = self.finish()
+
+        if status == "SUCCEEDED":
+            # Track the runtime
+            self.runtime = tiedot['UpdatedAt'] - tiedot['CreatedAt']
+
+            # Because we're using `UNLOAD`, we get a manifest of the files
+            # that make up our data.
+            manif = self.out + "manifest"
+            tmp   = self.handler.download(manif)
+            with open(tmp, "r") as f:
+                js = json.load(f)
+
+            # Filter empty strings
+            files = [e['url'].strip() for e in js['entries'] if e['url'].strip()]
+
+            return files
+        else:
+            return status # canceled or error
+
+    # TODO parallelize this
+    def results(self):
+        #local   = [self.handler.download(f) for f in self.manifest_files()]
+        local   = parallel_map(self.handler.download, self.manifest_files())
+        self.ds = pa.dataset.dataset(local)
+        return self.ds
+
diff --git a/minerva/s3.py b/minerva/s3.py
new file mode 100644
index 0000000..e69de29
diff --git a/pyproject.toml b/pyproject.toml
index 62631c5..6b127d4 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,7 +3,8 @@ name = "minerva"
 version = "0.2.1"
 description = "Easier access to AWS Athena and Redshift"
 authors = [
-  "Ari Brown <ari@airintech.com>"
+  "Ari Brown <ari@airintech.com>",
+  "Roshan Punnoose <roshan.punnoose@jhuapl.edu>"
 ]
 packages = [
   { include = "minerva/**/*.py"}
diff --git a/test.py b/test.py
index 8cf7a3f..eb64c67 100644
--- a/test.py
+++ b/test.py
@@ -1,9 +1,9 @@
-import minerva.minerva as a
+import minerva
 import pprint
 
 pp = pprint.PrettyPrinter(indent=4)
 
-athena = a.Athena("hay", "s3://haystac-pmo-athena/")
+athena = Athena("hay", "s3://haystac-pmo-athena/")
 #query  = athena.query(
 #"""SELECT *
 #FROM trajectories.kitware
diff --git a/test2.py b/test2.py
index c108da7..41d2dea 100644
--- a/test2.py
+++ b/test2.py
@@ -1,11 +1,11 @@
-import minerva.blueshift as b
+import minerva
 import pprint
 
 pp = pprint.PrettyPrinter(indent=4)
 
-red   = b.Redshift("hay", "s3://haystac-pmo-athena/",
-                   db="dev",
-                   cluster="redshift-cluster-1")
+red   = Redshift("hay", "s3://haystac-pmo-athena/",
+                 db="dev",
+                 cluster="redshift-cluster-1")
 query = red.query("select count(*) from myspectrum_schema.kitware")
 print(query)
 data  = query.results()