reflexive 1.2.0__tar.gz → 1.2.1__tar.gz

{reflexive-1.2.0 → reflexive-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reflexive
-Version: 1.2.0
+Version: 1.2.1
 Summary: Supports AWS Reflexive Expressions Systems (RES) Analysis
 Project-URL: Repository, https://github.com/nlytx/reflexive.git
 Author-email: Andrew Gibson <andrew@nlytx.io>

{reflexive-1.2.0 → reflexive-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reflexive"
-version = "1.2.0"
+version = "1.2.1"
 description = "Supports AWS Reflexive Expressions Systems (RES) Analysis"
 authors = [{name = "Andrew Gibson", email = "andrew@nlytx.io"}]
 readme = "README.md"

{reflexive-1.2.0 → reflexive-1.2.1}/src/reflexive/visualise.py

@@ -1,3 +1,6 @@
+from graph_tool.all import *
+import cairo
+
 from reflexive import session
 from reflexive import cfg
 
@@ -183,4 +186,151 @@ class Display:
                     b = v[0]
                     e = v[1]
             #print("New offsets:",len(new_offsets[k]))
-        return new_offsets
+        return new_offsets
+    
+class RES_graph:
+    
+    #
+    gt_props = {0:{ "lbl":"RR",
+                    "pos":(0.2,6.5),
+                    "clr":"#00AEEF"},
+                1:{ "lbl":"NR",
+                    "pos":(5,10),
+                    "clr":"#ED1B23"},
+                2:{ "lbl":"AR",
+                    "pos":(9.8,6.5),
+                    "clr":"#00A64F"},
+                3:{ "lbl":"AF",
+                    "pos":(7.9,1),
+                    "clr":"#EC008C"},
+                4:{ "lbl":"EP",
+                    "pos":(2.1,1),
+                    "clr":"#FFF200"}}
+                
+    
+    # re_props = {"RR":{
+    #                 "idx": 0,
+    #                 "pos":(0.2,6.5),
+    #                 "clr":"#00AEEF"},
+    #             "NR":{
+    #                 "idx": 1,
+    #                 "pos":(5,10),
+    #                 "clr":"#ED1B23"},
+    #             "AR":{
+    #                 "idx": 2,
+    #                 "pos":(9.8,6.5),
+    #                 "clr":"#00A64F"},
+    #             "AF":{
+    #                 "idx": 3,
+    #                 "pos":(7.9,1),
+    #                 "clr":"#EC008C"},
+    #             "EP":{
+    #                 "idx": 4,
+    #                 "pos":(2.1,1),
+    #                 "clr":"#FFF200"}}
+    
+    #
+    edges = dict()
+    #
+    iso_vertices = set()
+    #
+    v_label = None
+    #
+    v_color = None
+    #
+    v_pos = None
+
+    #
+    def __init__(self,matrix=None):
+        self._setup(matrix)
+    
+    #    
+    def _setup(self,matrix):
+        if matrix:
+            # Edges from matrix
+            self.edges = self._matrix_to_dict(matrix)
+            self.graph = Graph(g=self.edges.keys(),directed=False)
+            self.e_weight = self.graph.new_ep("double",vals=self.edges.values())
+            # Handle colour of isolated vertices
+            default_clrs = self._get_prop_values('clr')
+            actual_clrs = []
+            for i in range(5):
+                if i in self.iso_vertices:
+                    clr = "#cccccc"
+                else:
+                    clr = default_clrs[i]
+                actual_clrs.append(clr)
+            self.v_color = self.graph.new_vp("string",vals=actual_clrs)
+        else:
+            # No edges
+            self.graph = Graph(g=self._empty_edge_dict(),directed=False)
+            self.e_weight = self.graph.new_ep("double")
+            self.v_color = self.graph.new_vp("string",val="#cccccc")
+        # Vertex properties common to all graphs    
+        self.v_label = self.graph.new_vp("string",vals=self._get_prop_values('lbl'))
+        self.v_pos = self.graph.new_vp("vector<double>",vals=self._get_prop_values('pos'))
+        
+        
+
+    #
+    def _matrix_to_dict(self,matrix):
+        edges = {}
+        for r,row in enumerate(matrix):
+            # if empty row, add to iso_vertices
+            if sum(row) == 0:
+                self.iso_vertices.add(r)
+            else:
+                for c,weight in enumerate(row):
+                    if weight > 0:
+                        edge = tuple(sorted((r,c)))
+                        #print("r,c:",edge," - ",weight)
+                        edges[edge] = weight
+        return edges
+    
+    #
+    def _empty_edge_dict(self):
+        empty_edges = {}
+        for idx in self.gt_props.keys():
+            empty_edges[idx] = []
+        return empty_edges
+    
+    #
+    def _get_prop_values(self,key):
+        values_list =  self.gt_props.values()
+        return [p[key] for p in values_list]
+    
+    # flip coordinates for graph-tool
+    def _flipY(self,vpositions):
+        x, y = ungroup_vector_property(vpositions, [0, 1])
+        y.fa *= -1
+        y.fa -= y.fa.min()
+        return group_vector_property([x, y])
+    
+    #
+    def show(self,inline=True):
+        graph = self.graph
+        positions = self._flipY(self.v_pos)
+        labels = self.v_label
+        colors = self.v_color
+        weights = self.e_weight
+        graph_draw(graph, inline=inline,output_size=(300,300),fit_view=0.7,
+                        pos=positions, 
+                        vertex_text=labels,
+                        vertex_font_family="sans serif",
+                        vertex_font_size=18,
+                        vertex_font_weight=cairo.FONT_WEIGHT_BOLD,
+                        vertex_fill_color=colors,
+                        vertex_size = 50,
+                        vertex_halo=False,
+                        vertex_pen_width=1.2,
+                        vertex_color="#999999",
+                        edge_pen_width=weights)
+        
+    def get_vertex_labels(self):
+        return self._get_prop_values('lbl')
+    
+    def get_vertex_colours(self):
+        return self._get_prop_values('clr')
+    
+    def get_vertex_positions(self):
+        return self._get_prop_values('pos')

reflexive-1.2.1/tests/test_reflexive.py

@@ -0,0 +1,110 @@
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+import logging
+logging.basicConfig(level=logging.INFO)
+
+import json
+import pandas as pd
+import time
+
+import reflexive as rfx
+
+# Create a config with a profile (local credentials) - leave blank for 'default' profile
+cfg = rfx.cfg.Config('r3-admin')
+# Set default parameters - specify name_prefix, local_path, and date_string for custom options
+parameters = cfg.set_parameters()
+#print("After set_parameters:",parameters)
+
+# Create a session with AWS using profile - some parameters require AWS session (like account number)
+aws = rfx.session.AWS(cfg)
+#print("aws parameters:",cfg.get_parameters())
+
+# Set the parameters for S3 - required for comprehend
+parameters = cfg.set_s3_parameters(s3_access_point="qut-gibsonap-reflexive",s3_bucket_name="au-edu-qld-qut-gibsonap-reflexive")
+#print("After set_s3_parameters:",parameters)
+
+# Set comprehend parameters
+parameters = cfg.set_comprehend_parameters(comprehend_service_role_name="AmazonComprehendServiceRole-gibsonap-reflexive")
+#print("After set_comprehend_parameters:",parameters)
+
+# Set custom entity recogniser parameters
+parameters = cfg.set_comprehend_custom_entity_parameters(reflexive_entity_name="ReflexiveExpressionRecogniser",reflexive_entity_version="v17")
+#print("After set_comprehend_custom_entity_parameters:",parameters)
+
+# Display all parameters stored in Config
+params_fmt = json.dumps(parameters, indent=2)
+#print(params_fmt)
+
+# Create a new S3 client
+s3 = rfx.session.S3(aws)
+s3_client = s3.client()
+
+# Create a new Comprehend client
+comp = rfx.session.Comprehend(aws)
+comp_client = comp.client()
+
+# Perform test analysis
+test_dict = {"text":["This is a test text. I hope that this will work for some basic analysis. Previously, this has not been as straight forward as I thought. Perhaps this time may be different. With any luck, this will not be a frustrating experience, but I hope that it will just work straight away. I can only hope!"]}
+test_series = pd.Series(test_dict['text'])
+df = pd.DataFrame.from_dict(test_dict)
+#print(df.describe())
+
+nlp = rfx.analyse.Nlp(aws)
+
+# Text length - this is needed for comprehend analytics
+df = nlp.text_length(df)
+df = nlp.remove_IQR_outliers(df)
+#print(df.describe())
+
+# Domain terms
+#domain_terms = {"hedge":['hope','perhaps','luck'],"emotion":['hope','frustrating']}
+#nlp.add_domain_terms(domain_terms)
+#df = nlp.match_domain_terms(df)
+#print(df['domain_counts'])
+
+# Ngrams
+#top_ngrams = nlp.get_top_ngrams(df['text'],2)
+#print(top_ngrams)
+#df = nlp.match_top_ngrams(df)
+#print(df)
+
+# Comprehend analysis
+# results = nlp.comprehend_analysis(comp,df)
+# print(results)
+# errors = nlp.check_results(results)
+# print(errors)
+# if errors=={}:
+#    print("No errors, so adding results to dataframe")
+#    df = nlp.add_results_to_df(results,df)
+# print(df)
+
+# df.to_pickle(f"{cfg.local_path}comp_df.pkl")
+df = pd.read_pickle(f"{cfg.local_path}comp_df.pkl")
+
+# Comprehend analytics
+df = nlp.comprehend_analytics(df)
+df.to_csv(f"{cfg.local_path}comp_analytics.csv")
+print("DONE!!")
+
+# Reflexive expression analysis
+response = nlp.analyse_reflexive_expressions(df,s3,comp)
+print(response)
+job_id = comp.get_current_job_id()
+time.sleep(5)
+status = comp.check_job_status()
+print(status)
+time.sleep(5)
+details = comp.get_job_details()
+print(details)
+
+while status=="IN_PROGRESS":
+    time.sleep(10)
+    status = comp.check_job_status()
+    print(status)
+
+result = comp.download_and_extract(s3)
+print(result)
+
+