reflexive 0.1.9__py3-none-any.whl → 1.0.13__py3-none-any.whl

reflexive/analyse/general.py

@@ -1,128 +0,0 @@
-
-import logging,coloredlogs
-import pandas as pd
-import json
-
-from reflexive.common.parameters import Parameters
-from reflexive.common.util import Util
-
-coloredlogs.install(level='INFO')
-
-class General:
-    
-    logger = logging.getLogger(__name__)
-    
-    def __init__(self,parameters:Parameters):
-        #print(parameters)
-        self.__parameters = parameters.all_parameters()
-        self.logger.debug(f"Parameters: {self.__parameters}")
-
-
-    def general_analytics(self,df):
-        util = Util()
-        custom_df = df.copy() 
-        custom_df["text_length"] = df.text.apply(lambda x: len(x))
-        if (len(custom_df)>1):
-            custom_df["text_scaled"] = util.scale_min_max(custom_df[['text_length']])
-        else:
-            custom_df["text_scaled"] = 1
-        return custom_df
-
-
-    def remove_IQR_outliers(self,df):
-        tempdf = df.copy()
-        # Calculate text length
-        tempdf["text_length"] = tempdf.text.apply(lambda t: len(t))
-        fence = Util.outlier_fence(tempdf.text_length)  
-        print(fence)
-        # Check change with removed outliers
-        checkdf = tempdf[tempdf.text_length<fence['UPPER']]
-        checkdf.reset_index(drop=True,inplace=True)
-        print("Original:",len(tempdf))
-        print(tempdf.describe())
-        print()
-        print("Outliers:",len(tempdf)-len(checkdf))
-        print()
-        print("No outliers:",len(checkdf))
-        print(checkdf.describe())
-        return checkdf
-
-    # Parse text for domain terms
-    def parse_domain_terms(self,text,domain_terms):
-        matched_terms = {}
-        for dtk,dtv in domain_terms.items():
-            matched_terms[dtk] = []
-            for term in dtv:
-                if term[0]=='_': #acronym - treat as whole word
-                    regex = r"\b{}\b".format(term[1:])
-                    matches = re.findall(regex,str.lower(text))
-                    if len(matches)>0:
-                        matched_terms[dtk].append((term[1:],len(matches)))
-                else:
-                    count = str.lower(text).count(term)
-                    if count > 0:
-                        matched_terms[dtk].append((term,count))
-        return matched_terms
-    
-    
-    def get_top_ngrams(self,text_series,min_val=3):
-        ngrams = {}
-        for text in text_series:
-            self.__ngrams345(text,ngrams)
-        #print("Generated 3,4,5 ngrams:", len(ngrams))
-        f_ngrams = self.filter_dict_by_value(ngrams,min_val)
-        return self.sort_dict_by_value(f_ngrams)
-
-    def get_top_ngrams_for_text(self,text,top_ngrams):
-        ngrams = self.__ngrams345(text,{})
-        return {key: ngrams[key] for key in top_ngrams.keys() if key in ngrams}
-
-    def ngram_counts(self,ref_top_ngrams):
-        return sum(ref_top_ngrams.values())
-    
-        # Given text and number of terms, create ngrams from the text
-    def __make_ngrams(self,text, n=1):
-        # Replace all none alphanumeric characters with spaces
-        s = re.sub(r'[^a-zA-Z0-9\s]', ' ', text.lower())
-        
-        tokens = [token for token in s.split(" ") if token != ""]
-        ngrams = zip(*[tokens[i:] for i in range(n)])
-        return [" ".join(ngram) for ngram in ngrams]
-
-    # Generate 3,4,5 -grams
-    def __ngrams345(self,text,ngrams):
-        ngrams3 = self.__make_ngrams(text,3)
-        for n in ngrams3:
-            ngrams[n] = ngrams.get(n,0)+1
-        ngrams4 = self.__make_ngrams(text,4)
-        for n in ngrams4:
-            ngrams[n] = ngrams.get(n,0)+1
-        ngrams5 = self.__make_ngrams(text,5)
-        for n in ngrams5:
-            ngrams[n] = ngrams.get(n,0)+1
-        return ngrams
-    
-
-    # Count domain terms
-    def count_domain_terms(self,terms):
-        counts = {}
-        for k,v in terms.items():
-            for term in v:
-                counts[k] = counts.setdefault(k,0) + term[1]
-        return counts
-
-
-    # Ratio between action POS and object POS
-    def action_object_ratio(self,pos_ratios,action_pos = ['VERB'],object_pos = ['NOUN','PROPN']):
-        ap = [s[1] for s in pos_ratios if s[0] in action_pos]
-        if ap:
-            aps = sum(ap)
-        else:
-            aps = 0
-        op = [s[1] for s in pos_ratios if s[0] in object_pos]
-        if op:
-            ops = sum(op)
-        else:
-            ops = 1 #avoid divide zero error - only happens with aps of 1
-            #print("aps",aps,"ops",ops)
-        return aps/ops

reflexive/analyse/reflexive_expressions.py

@@ -1,124 +0,0 @@
-#
-
-import logging,coloredlogs
-import pandas as pd
-import json
-
-from reflexive.common.parameters import Parameters
-from reflexive.common.local import Local
-from reflexive.common.util import Util
-from reflexive.aws_connect.s3 import S3
-from reflexive.aws_connect.comprehend import Comprehend
-
-
-coloredlogs.install(level='INFO')
-
-class ReflexiveExpressions:
-    
-    logger = logging.getLogger(__name__)
-    
-    def __init__(self,parameters:Parameters,aws_s3:S3,local:Local,comprehend:Comprehend):
-        #print(parameters)
-        self.__params = parameters
-        self.__parameters = parameters.all_parameters()
-        self.logger.debug(f"Parameters: {self.__parameters}")
-        self.prefix = self.__parameters['prefix']
-        self.postfix = self.__parameters['postfix']
-        self.local_path = self.__parameters['local_path']
-        self.__s3 = aws_s3
-        self.__local = local
-        self.__comprehend = comprehend
-
-        
-    ######## REFLEXIVE EXPRESSION ANALYSIS FUNCTIONS
-
-    def analyse_reflexive_expressions(self,df): #,s3_bucket_name,access_role_arn,entity_recogniser_arn):
-        #self.__bucket_name = s3_bucket_name
-        text = df.text.replace('\r\n','\n') # Comprehend treats \r\n as one character
-        # Upload reflections to S3 for analysis
-        self.__s3.upload_docs(text)
-        
-        # Save a copy of reflections locally for offline analysis
-        self.__local.save_docs(text)
-
-        # Submit the job
-        return self.__comprehend.submit_custom_entity_job("reflexive_expressions_analysis") #submitReflexiveExpressionsJob(access_role_arn, entity_recogniser_arn)
-    
-    def check_job_status(self):
-        return self.__comprehend.check_job_status()
-    
-    def get_job_details(self):
-        return self.__comprehend.get_job_details()
-
-    def download_and_extract(self):
-        local_output_dir = f"{self.local_path}{self.prefix}output{self.postfix}"
-        job_details = self.get_job_details()
-        s3Uri = job_details['OutputDataConfig']['S3Uri']
-        return self.__s3.results_download_save_extract(s3Uri,local_output_dir)
-
-    def extractAnalysisFromResults(self,results):
-        analysis_output = dict()
-        for result in results:
-            j = json.loads(result)
-            #print(j)
-            idx = j["File"].split('_')[-1].split('.')[0]
-            analysis_output[int(idx)] = j["Entities"]
-        return analysis_output
-    
-    def add_to_dataframe(self,df,results):
-        # Extract analysis from raw results
-        analysis_output = self.extractAnalysisFromResults(results)
-        # Add results to dataframe
-        results_df = df.copy()
-        results_df['reflexiveResults'] = pd.Series(analysis_output)
-        return results_df
-
-    def reflexive_analytics(self,df):
-        util = Util()
-        custom_df = df.copy() 
-        # custom_df["text_length"] = df.text.apply(lambda x: len(x))
-        # if (len(custom_df)>1):
-        #     custom_df["text_scaled"] = util.scale_min_max(custom_df[['text_length']])
-        # else:
-        #     custom_df["text_scaled"] = 1
-        custom_df["reflexive_results"] = df.reflexiveResults
-        # The expressions and their reflexive expression labels
-        custom_df["reflexive_expressions"] = df.reflexiveResults.apply(self.parse_reflexiveResults)
-        # The counts for each labels
-        custom_df["reflexive_counts"] = custom_df.reflexive_expressions.apply(util.count_labels)
-        # Ratios between reflexive expressions
-        custom_df["reflexive_ratio"] = custom_df.reflexive_counts.apply(util.ratios)
-        # Ratio vector
-        custom_df['ratio_vector'] = custom_df.reflexive_ratio.apply(self.make_ratio_vector)
-        # Get the diversity of reflexive types - out of 8 possible types
-        custom_df["reflexive_type_diversity"] = custom_df.reflexive_counts.apply(lambda x: len(x)/8)
-        # A total of all labels
-        custom_df["reflexive_total"] = custom_df.reflexive_counts.apply(util.tuple_values_total)
-        # MinMax scale the reflexive_total
-        if (len(custom_df)>1):
-            custom_df["reflexive_scaled"] = util.scale_min_max(custom_df[['reflexive_total']])
-        else:
-            custom_df["reflexive_scaled"] = 1
-        # Normalise based on text_scaled
-        custom_df['reflexive_norm'] = util.normalise_scaled(custom_df,'reflexive_scaled')
-        return custom_df
-
-
-    # Parse reflexive results - include all above threshold
-    def parse_reflexiveResults(self,reflexiveResults,threshold=0.5):
-        final_refs = list()
-        for ref in reflexiveResults:
-            if ref['Score'] > threshold:
-                final_refs.append((str.lower(ref['Text']),ref['Type']))
-        return final_refs
-    
-        # Function for creating a vector out of reflexive ratio - could be used for others
-    def make_ratio_vector(self,ratio_list,ref_codes = ['RR','ER','VR','AR','EP','AF','CN','EV']):
-        ratio_dict = dict(ratio_list)
-        vec = []
-        for rc in ref_codes:
-            if rc in ratio_dict.keys():
-                vec.append(ratio_dict[rc])
-            else:
-                vec.append(0)
-        return vec

reflexive/aws_connect/comprehend.py

@@ -1,205 +0,0 @@
-#
-
-
-import boto3
-import time
-import json
-import pandas as pd
-
-from reflexive.common.parameters import Parameters
-from reflexive.common.util import Util
-from reflexive.aws_connect.s3 import S3
-
-import logging
-try:
-    import coloredlogs
-    coloredlogs.install(level='INFO')
-except:
-    print("Colored logs not available")
-
-class Comprehend:
-    
-    logger = logging.getLogger(__name__)
-    
-    def __init__(self,parameters:Parameters):
-        #print(parameters)
-        self.__parameters = parameters.all_parameters()
-        self.logger.debug(f"Parameters: {self.__parameters}")
-        self.region = self.__parameters['region']
-        self.access_role_arn = self.__parameters['comprehend_access_role_arn']
-        self.entity_recogniser_arn = self.__parameters['reflexive_entity_arn']
-        self.local_path = self.__parameters['local_path']
-        self.prefix = self.__parameters['prefix']
-        self.postfix = self.__parameters['postfix']
-        self.bucket_name = self.__parameters["bucket_name"]
-        self.files_folder = f"{self.prefix}files{self.postfix}"
-        self.results_folder = f"{self.prefix}results{self.postfix}"
-        self.input_uri = f"s3://{self.bucket_name}/{self.files_folder}/{self.prefix}"
-        self.output_uri = f"s3://{self.bucket_name}/{self.results_folder}/"
-        self.analysis_types = self.__parameters['analysis_types']
-        # create client
-        try:
-            self.logger.debug(f"Region:{self.region}")
-            self.__comp_client = boto3.client(service_name='comprehend',region_name=self.region)
-        except Exception as err:
-            self.logger.error("Unable to create Comprehend client: ",err)
-            
-        
-    def client(self):
-        return self.__comp_client
-        
-        
-#### CUSTOM ENTITY
-
-    def submit_custom_entity_job(self,job_name): #access_role_arn,entity_recogniser_arn):
-        job_str = f"{self.prefix}{job_name}{self.postfix}"
-    
-        response = self.__comp_client.start_entities_detection_job(
-            InputDataConfig={
-                'S3Uri': self.input_uri,
-                'InputFormat': 'ONE_DOC_PER_FILE'
-            },
-            OutputDataConfig={
-                'S3Uri': self.output_uri
-            },
-            DataAccessRoleArn=self.access_role_arn,
-            JobName=job_str,
-            EntityRecognizerArn=self.entity_recogniser_arn,
-            LanguageCode='en'
-        )
-        self.job_id = response['JobId']
-        return response
-    
-            # Check job status
-    def check_job_status(self):
-        job_status = self.__comp_client.describe_entities_detection_job(
-            JobId=self.job_id
-        )
-        self.__job_properties = job_status['EntitiesDetectionJobProperties'] 
-        return self.__job_properties['JobStatus']
-
-    def get_job_details(self):
-        return self.__job_properties
-    
-        
-    # Use AWS comprehend to get bulk key phrases from single batch of chunked text
-    def get_single_batch_analysis(self,index,chunk):
-        comprehend = self.client()
-        results = {}
-        print("Analysing chunk",index)
-        print(" . key_phrase")
-        kpresult = comprehend.batch_detect_key_phrases(TextList=chunk,LanguageCode='en')
-        results['KeyPhraseResults'] = kpresult
-        #key_phrase_results.append(kpresult)
-        time.sleep(2)
-        print(" . sentiment")
-        senresult = comprehend.batch_detect_sentiment(TextList=chunk,LanguageCode='en')
-        results['SentimentResults'] = senresult
-        #sentiment_results.append(senresult)
-        time.sleep(2)
-        print(" . targeted_sentiment")
-        tsenresult = comprehend.batch_detect_targeted_sentiment(TextList=chunk,LanguageCode='en')
-        results['TargetedSentimentResults'] = tsenresult
-        #target_sent_results.append(tsenresult)
-        time.sleep(2)
-        print(" . syntax")
-        synresult = comprehend.batch_detect_syntax(TextList=chunk,LanguageCode='en')
-        results['SyntaxResults'] = synresult
-        #syntax_results.append(synresult)       
-        time.sleep(2)
-        return results
-
-
-    # Use AWS comprehend to get bulk key phrases from chunked text
-    def get_multiple_batch_analysis(self,chunked_text):
-        chunk_results = {}
-        for key in self.analysis_types.keys():
-            chunk_results[key] = []
-                
-        for idx,chunk in enumerate(chunked_text):
-            if len(chunked_text) > 4999:
-                print("WARNING: Text too long to analyse - index",idx,"skipped!")
-            else:
-                try:
-                    results = self.get_single_batch_analysis(index=idx,chunk=chunk)
-                except(Exception) as error:
-                    print("There was an error with index",idx,error)
-                finally:
-                    if results:
-                        for key in results.keys():
-                            chunk_results[key].append(results[key])
-
-        return chunk_results
-
-    # Take batched responses and concenate single lists of results, errors, and http responses
-    def unbatch_results(self,result_type,results,batch_size=25):
-        unbatched_results = {}
-        unbatched_errors = {}
-        batch_responses = {}
-        for idx,batch in enumerate(results):
-            #print("Response for batch:",idx)
-            batch_responses[idx] = batch['ResponseMetadata']
-            result_list = batch['ResultList']
-            error_list = batch['ErrorList']
-            for r in result_list:
-                ridx = idx*batch_size + r['Index']
-                rdata = r[result_type]
-                unbatched_results[ridx] = rdata
-            for e in error_list:
-                eidx = e['Index']
-                unbatched_errors[eidx] = 'ERROR' + e['ErrorCode'] + ': ' + e['ErrorMessage']
-        unbatched = {}
-        unbatched['results'] = unbatched_results
-        unbatched['errors'] = unbatched_errors
-        unbatched['responses'] = batch_responses
-        return unbatched
-
-
-
-    def check_long_text(self,df):
-        # Check for long reflections (too long for batch analysis)
-        long_df = df.copy()
-        long_df = long_df[long_df.text.str.len()>5000]
-        long_df['length'] = long_df.text.str.len()
-        return long_df
-    
-    
-    # def extract_result(self,result,batch,batch_params):
-    #     match batch:
-    #         case "KeyPhraseResults":
-    #             extracted = [r['Text'] for r in result if r['Score'] >= batch_params["min_score"]]
-    #         case "SentimentResults":
-    #             extracted = result
-    #         case "TargetedSentimentResults":
-    #             extracted = dict()
-    #             for r in result:
-    #                 for mention in r['Mentions']:
-    #                     if (mention['Score'] >= batch_params["min_score"]):
-    #                         text = mention['Text']
-    #                         key = f"{mention['Type']}_{mention['MentionSentiment']['Sentiment']}"
-    #                         if key in extracted.keys():
-    #                             extracted[key].add(text)
-    #                         else:
-    #                             extracted[key] = {text}
-    #         case "SyntaxResults":
-    #             tags = []
-    #             tokens = []
-    #             for r in result:
-    #                 pos = r['PartOfSpeech']
-    #                 tag = pos['Tag']
-    #                 if pos['Score'] < batch_params["max_score"]:
-    #                     tag = tag+"_?"
-    #                 tags.append(tag)
-    #                 tokens.append(r['Text'])
-
-    #             extracted = {'tokens':tokens,'tags':tags}
-    #         case other:
-    #             extracted = []
-    #     return extracted
-
-
-
-
-
-
-

reflexive/aws_connect/s3.py

@@ -1,89 +0,0 @@
-#
-
-import logging,coloredlogs
-import boto3
-import pandas as pd
-import tarfile
-import json
-
-from reflexive.common.parameters import Parameters
-
-coloredlogs.install(level='INFO')
-
-class S3:
-    
-    logger = logging.getLogger(__name__)
-    
-    def __init__(self,parameters:Parameters):
-        #print(parameters)
-        # set local parameters
-        self.__parameters = parameters.all_parameters()
-        self.logger.debug(f"Parameters: {self.__parameters}")
-        self.region = self.__parameters['region']
-        self.prefix = self.__parameters['prefix']
-        self.postfix = self.__parameters['postfix']
-        self.s3_access_point_arn = self.__parameters["s3_accesspoint_arn"]
-        self.bucket_name = self.__parameters["bucket_name"]
-        # create client
-        try:
-            self.logger.debug(f"Region:{self.region}")
-            self.__s3_client = boto3.client(service_name='s3',region_name=self.region)
-        except Exception as err:
-            self.logger.error("Unable to create S3 client: ",err)
-    
-    
-    # Return the S3 client
-    def client(self):
-        return self.__s3_client
-    
-     # Function to upload reflections to S3
-    def upload_docs(self,text_series):
-        #self.__prefix, self.__postfix
-        files_folder = f"{self.prefix}files{self.postfix}"
-
-        s3 = self.__s3_client
-        s3ap = self.s3_access_point_arn
-        self.logger.debug(f"ACCESS POINT: {s3ap}")
-
-        self.logger.info(f"Uploading {len(text_series)} reflections to S3 ({files_folder})...")
-        self.logger.debug(f"({s3ap}/{files_folder})")
-        for idx in text_series.index:
-            file_name = f"{self.prefix}{idx}.txt"
-            file_body = text_series.iloc[idx]
-            self.logger.info(f"Uploading {file_name}")
-            #print(file_body)
-            response = s3.put_object(Body=file_body,Bucket=s3ap,Key=f"{files_folder}/{file_name}")
-            if response['ResponseMetadata']['HTTPStatusCode'] != 200:
-                self.logger.error("------------------------------------------------------------")
-                self.logger.error(f"ERROR: There was a problem with {file_name}")
-                self.logger.error(response)
-                self.logger.error("------------------------------------------------------------")
-            else:
-                self.logger.info('Success')
-        self.logger.info("Finished uploading reflections to S3.")
-        return response
-    
-    # download and save results
-    def results_download_save_extract(self,s3Uri,local_file_path):
-        s3 = self.__s3_client
-        output_key = s3Uri.split(self.bucket_name)[1]
-        # download from S3 to local path
-        with open(f"{local_file_path}.tar.gz",'wb') as output_data:
-            s3.download_fileobj(self.bucket_name,output_key[1:],output_data)
-
-        # extract the files from tar archive
-        files = list()
-        with tarfile.open(f"{local_file_path}.tar.gz", "r:gz") as tf:
-            for member in tf.getmembers():
-                f = tf.extractfile(member)
-                if f is not None:
-                    content = f.read()
-                    files.append(content)
-        #print("Number of files:",len(files))
-        # extract results and save and return
-        raw_results = files[0].decode("utf-8").split('\n')
-        raw_results.pop() # pop last item off as empty entry due to final \n
-        with open(f"{local_file_path}.json","w") as fp:
-            fp.write(json.dumps(raw_results))
-        return raw_results
-        

reflexive/common/local.py

@@ -1,48 +0,0 @@
-
-import os
-import logging,coloredlogs
-#import boto3
-import pandas as pd
-
-from reflexive.common.parameters import Parameters
-
-coloredlogs.install(level='INFO')
-
-class Local:
-    
-    logger = logging.getLogger(__name__)
-    
-    def __init__(self,parameters:Parameters):
-        self.__parameters = parameters.all_parameters()
-        self.logger.debug(f"Parameters: {self.__parameters}")
-        self.local_path = self.__parameters['local_path']
-        self.local_dir = self.local_path
-        self.logger.info(f"Path: {self.local_path}")
-        self.prefix = self.__parameters['prefix']
-        self.postfix = self.__parameters['postfix']
-        
-    def get_data_path_name(self,name,ext):
-        return f"{self.local_path}{self.prefix}{name}{self.postfix}.{ext}"
-        
-    def set_sub_dir(self,sub_dir=None):
-        # check dir sub_dir exists
-        if sub_dir:
-            self.local_dir = f"{self.local_path}{sub_dir}/"
-            self.logger.debug(f"local_dir: {self.local_dir}")
-            dirExists = os.path.exists(self.local_dir)
-            if not dirExists:
-                self.logger.info(f"Creating subdirectory: {self.local_dir}")
-                os.makedirs(self.local_dir)
-        else:
-            self.local_dir = self.local_path
-        
-    def save_docs(self,text_series,):
-        self.logger.info(f"Saving {len(text_series)} docs to {self.local_dir}...")
-        for idx in text_series.index:
-            file_name = f"{self.prefix}{idx}.txt"
-            file_body = text_series.iloc[idx]
-            self.logger.info(f"Saving {file_name}")
-            with open(f"{self.local_dir}{file_name}",'w') as fp:
-                fp.write(file_body) 
-        self.logger.info("Finished saving reflections locally.")
-        

reflexive/common/parameters.py

@@ -1,77 +0,0 @@
-# Store the parameters for connecting to AWS
-
-import os
-import logging,coloredlogs
-from datetime import datetime
-import boto3
-
-coloredlogs.install(level='INFO')
-
-class Parameters:
-    
-    logger = logging.getLogger(__name__)
-
-    def __init__(self,profile="default",name_prefix="refex",local_path=None,date_string=None):
-        working_dir = os.getcwd()
-        try:
-            aws_session = boto3.Session(profile_name=profile)
-            self.region = aws_session.region_name
-            self.logger.info("AWS region:",self.region)
-            self.access_key = aws_session.get_credentials().access_key
-            self.logger.debug("AWS access key:",self.access_key)
-            self.account_number = aws_session.client('sts').get_caller_identity().get('Account')
-        except Exception as err:
-            self.logger.error("Unable to retrieve AWS credentials",err)
-            self.access_key = None
-            self.region = None
-            self.account_number = None
-        
-        # AWS specific
-        
-        self.analysis_types = {
-            "KeyPhraseResults":"KeyPhrases",
-            "SentimentResults":"Sentiment",
-            "TargetedSentimentResults":"Entities",
-            "SyntaxResults":"SyntaxTokens"
-        }
-        # General parameters
-        
-        if not local_path:
-            self.logger.warning("No path supplied, creating a data directory...")
-            #print(f"WD: {working_dir}")
-            data_dir = working_dir+"/data/"
-            if not os.path.exists(data_dir):
-                os.makedirs(data_dir)
-                self.logger.info("Created:",data_dir)
-            self.local_path = data_dir
-        else:
-            data_dir = local_path
-            if not os.path.exists(data_dir):
-                self.logger.warning("Path does not exist, creating directory")
-                os.makedirs(data_dir)
-                self.logger.info(f"Created {data_dir}")
-            self.local_path = local_path
-        if not date_string:
-            date_string = datetime.today().strftime('%Y%m%d')
-            self.logger.warning(f"No date_string supplied, using today: {date_string}")
-        self.date_string = date_string
-        self.prefix = f"{name_prefix}_"
-        self.postfix = f"-{date_string}"
-        return None
-    
-    def all_parameters(self):
-        return self.__dict__
-    
-    def set_s3_parameters(self,s3_access_point,bucket_name):
-        self.s3_access_point = s3_access_point
-        self.bucket_name = bucket_name
-        self.s3_accesspoint_arn = f"arn:aws:s3:{self.region}:{self.account_number}:accesspoint/{s3_access_point}"
-        
-    def set_comprehend_parameters(self,comprehend_service_role_name):
-        self.comprehend_service_role_name = comprehend_service_role_name
-        self.comprehend_access_role_arn = f"arn:aws:iam::{self.account_number}:role/service-role/{comprehend_service_role_name}"
-        
-    def set_comprehend_custom_entity_parameters(self,reflexive_entity_name,reflexive_entity_version):
-        self.reflexive_entity_name = reflexive_entity_name
-        self.reflexive_entity_version = reflexive_entity_version
-        self.reflexive_entity_arn = f"arn:aws:comprehend:{self.region}:{self.account_number}:entity-recognizer/{self.reflexive_entity_name}/version/{self.reflexive_entity_version}"