def buildFollowership(self):
        # get the follower list
        user_profile = UserProfile()
        user_profile.getUserList()
        self.follower_list = user_profile.user_list 

        #convert to set to speed up index
        follower_set = set(self.follower_list)
        print(len(follower_set))

        db = DB()

        
        result = db.db[config.followeroffollower_collection_name].find()

        for doc in result:
            if doc['user_id'] not in follower_set:
                continue
            if doc['user_id'] not in self.followership_dict:
                self.followership_dict[doc['user_id']] = []
            if doc['followerID'] not in follower_set:
                # this follower is not in the target comnunitiy, 
                # which is the followers of the target users defined in config.py
                continue

            self.followership_dict[doc['user_id']].append(doc['followerID'])

        db.close()
Example #2
0
 def __init__(self):
     self.user_corp = {}
     self.corp_dict = {}
     self.corp_bow = []
     self.user_profile = UserProfile()
     self.user_profile.getUserList()
     self.user_list = self.user_profile.user_list
     self.cosine_distance_dict = {}
     self.lda_vect_dict = {}
def upload_hairstyle(request_obj):
    if 'selfie' not in request_obj.files and 'gender' not in request_obj.form and 'category' not in request_obj.form and 'style' not in request_obj.form:
        return "failed status.HTTP_400_BAD_REQUEST"

    # selfie is assumed to be of type bytes
    selfie = request_obj.files['selfie']
    username = request_obj.form['username']
    gender = request_obj.form['gender']
    category = request_obj.form['category']
    style = request_obj.form['style']

    hair_model_path = os.path.dirname(
        __file__) + '/file_storage/trash/temp_files/hair_model.jpg'

    # if a file is currently stored at the users_face_path delete file
    if os.path.isfile(hair_model_path):
        os.remove(hair_model_path)

    if type(selfie) == np.ndarray:
        # no need for type conversion.
        cv2.imwrite(hair_model_path, selfie)
        pass
    else:
        # selfie is of type bytes. Store at the users_face_path location.
        selfie.save(hair_model_path)

    UserProfile(username).upload_hairstyle(hair_model_path, gender, category,
                                           style)

    return "saved"
def sign_up(request_obj):
    """
    Collect and store new user's username, password, profile pic & gender.
    :param request_obj: request object containing the new user's name and gender in a request form.
    :return:
    """
    if 'username' not in request_obj.form and 'gender' not in request_obj.form and 'password' not in request_obj.form and 'selfie' not in request_obj.files:
        return "failed status.HTTP_400_BAD_REQUEST FORMAT"
    username = request_obj.form['username']
    gender = request_obj.form['gender']
    password = request_obj.form['password']
    selfie = request_obj.files['selfie']

    users_face_path = os.path.dirname(
        __file__) + '/file_storage/trash/temp_files/profile_pic.jpg'

    # if a file is currently stored at the users_face_path delete file
    if os.path.isfile(users_face_path):
        os.remove(users_face_path)

    if type(selfie) == np.ndarray:
        # save to system folder, at the users_face_path location.
        cv2.imwrite(users_face_path, selfie)

    else:
        # save to system folder, at the users_face_path location.
        selfie.save(users_face_path)

    # create an instance of a user with name username and add details of the user.
    UserProfile(username).add_user(password, gender, users_face_path)
    # if successful then
    status = 'success '

    return status
Example #5
0
class TestWriteToFile(unittest.TestCase):
    database = DataManipulator()
    user = UserProfile(None,'Tester', '*****@*****.**', '0000')
    def test_create_user(self):
        result = self.database.add_new_user(self.user)
        self.assertEqual(True, result) 

    def test_create_page(self):
        page = Page('testpage',None,self.user.get_id())
        result = self.database.write_page_to_file(page.to_json())  
        self.assertEqual(True, result)   
    
    def test_create_group(self):
        group = Group('testgroup',None,self.user.get_id())
        result = self.database.write_group_to_file(group.to_json())
        self.assertEqual(True, result)

    def test_create_event(self):
        event = Event('testing event',None,self.user.get_id())
        event.set_place('at home')
        event.set_date('13/01/2020')
        event.set_time('15:55')
        event.set_about('testing the functionality of testing unit')
        result = self.database.write_event_to_file(event.to_json())
        self.assertEqual(True, result)

    def test_create_post(self):
        post_content = 'this is a sample post to test the functionality of the test unit'
        post = Post(id=None, owner =self.user.get_id(),content=post_content)
        result = self.database.write_post(post.to_json())
        self.assertEqual(True, result)
Example #6
0
    def __init__(self,
                 user_name,
                 hairstyle_category='All',
                 style='All',
                 index='All'):
        """

        :param user_name:
        :param hairstyle_category:
        """
        self.hairstyle_category = hairstyle_category
        self.style = style
        self.index = index
        self.user_name = user_name
        self.user_profile = UserProfile(user_name).profile()
def sign_in(request_obj):
    """
    Collect and store new user's username, password, profile pic & gender.
    :param request_obj: request object containing the new user's name and gender in a request form.
    :return:
    """
    if 'username' not in request_obj.form and 'password' not in request_obj.form:
        return "failed status.HTTP_400_BAD_REQUEST FORMAT"
    username = request_obj.form['username']
    password = request_obj.form['password']
    # create an instance of a user with name username and add details of the user.
    UserProfile(username).sign_in(password)
    # if successful then
    status = 'success '

    return status
    def create_new_user(self):
        """This function is used to create new users"""
        name = input('Enter user name: ')
        used_emails = [
            user.get_email() for user in self.database.users.values()
        ]
        while True:
            email = input('Enter user email: ')
            if email in used_emails:
                print('email is already available in the system')
            else:
                break
        while True:
            password = input('Enter user password: '******'Re-enter user password: '******'Create user? (y/n)')
        if confirm.lower() == 'y' or confirm.lower() == 'yes':
            user = UserProfile(None, name, email, password)
            self.database.add_new_user(user)
Example #9
0
    def __read_users(self):
        """This function is used to read the information of all users
        stored in the directory /data/users. Every file is named using the 
        ID of the user and contains his/her name,email, password,list of friends,
        list of owned pages, list of followed pages, list of owned groups, list of joined groups
        and list of events in a json format. """

        path = os.path.join(self.cwd,'data/users')
        available_users = os.listdir(path)
        if len(available_users)>0:
            for  user_id in available_users:
                if user_id == 'README.md':
                    continue
                #assuming the user data was stored in JSON format
                with open(os.path.join(path,user_id),'r') as file:
                    user_data = json.load(file)
                    user = UserProfile(user_data['id'],user_data['name'], user_data['email'], 
                                        user_data['password'], user_data['timeline'])
                    user.init_friends(user_data['friends'])
                    user.init_my_groups(user_data['my_groups'])
                    user.init_joined_groups(user_data['joined_groups'])
                    user.init_my_pages(user_data['my_pages'])
                    user.init_followed_pages(user_data['followed_pages'])
                    user.init_events(user_data['my_events'])
                    self.users[user_id.split('.')[0]]=user 
Example #10
0
 def add_new_user(self, user: UserProfile):
     self.users[user.get_id()] =user
     self.pages[user.timeLine.get_id()]= user.timeLine
     result1 = self.write_user_to_file(user.to_json())
     result2 = self.write_page_to_file(user.timeLine.to_json()) 
     return result1== True and result2 == True 
Example #11
0
from userProfile import UserProfile

user_profile = UserProfile()

user_profile.buildCorpProfile()
Example #12
0
class LdaRecsys:
    def __init__(self):
        self.user_corp = {}
        self.corp_dict = {}
        self.corp_bow = []
        self.user_profile = UserProfile()
        self.user_profile.getUserList()
        self.user_list = self.user_profile.user_list
        self.cosine_distance_dict = {}
        self.lda_vect_dict = {}

    def loadCorpDict(self, user_list=[]):
        return

    def saveCorpDict(self):
        return

    def buildCorpDict(self, user_list=[], no_blow_doc=10, no_above_doc=0.5):

        if not user_list:
            if not self.user_list:
                print('user list is empty! will run getUserList')
                self.user_profile.getUserList()
                self.user_list = self.user_profile.user_list
                print('get the user list')

            user_list = self.user_list

        if not user_list:
            print('user list is still empty!')
            return []

        self.user_corp = self.user_profile.getCorpProfile(self.user_list)

        self.corp_dict = Dictionary(
            [corp for corp in list(self.user_corp.values())])

        # Keep tokens which are contained in at least no_below documents
        # Keep tokens which are contained in no more than no_above documents
        # (fraction of total corpus size, not an absolute number)
        self.corp_dict.filter_extremes(no_below=no_blow_doc,
                                       no_above=no_above_doc)
        self.corp_dict.compactify()

    def buildCorpBow(self):
        if not self.user_corp or not self.corp_dict:
            self.buildCorpDict()

        self.corp_bow = {}
        for user, corp in self.user_corp.items():
            self.corp_bow[user] = self.corp_dict.doc2bow(corp)

    def saveCorpBow(self):
        return

    def loadCorpBow(self):
        return

    def trainLDA(self, topics_num, iter_num=50):
        # reset the cosine_distance_dict in every training
        self.cosine_distance_dict = {}

        self.topics_num = topics_num
        corp_bow = [bow for bow in list(self.corp_bow.values())]
        self.lda = LdaMulticore(corp_bow,
                                num_topics=topics_num,
                                id2word=self.corp_dict,
                                iterations=iter_num,
                                workers=4)

    def runLDA(self, user_name):
        if user_name in self.corp_bow:
            user_bow = self.corp_bow[user_name]
        else:
            print('no such user! Please check the screen name')
            return

        user_lda = self.lda[user_bow]

        return user_lda

    def buildLdaVect(self):

        for user, bow in self.corp_bow.items():
            vect = np.zeros(self.topics_num)
            user_lda = self.lda[bow]

            for i in user_lda:
                vect[i[0]] = i[1]

            self.lda_vect_dict[user] = vect

    def ldaCosineDistance(self, user_name):

        if not self.lda_vect_dict:
            self.buildLdaVect()

        if user_name not in self.lda_vect_dict:
            print('no such user')
            return

        cosine_distance_dict = {}
        user_vect = self.lda_vect_dict[user_name]

        for user, lda_vect in self.lda_vect_dict.items():
            cosine_distance = pairwise_distances(
                np.array(user_vect).reshape(1, -1),
                np.array(lda_vect).reshape(1, -1),
                metric='cosine')[0][0]
            cosine_distance_dict[user] = cosine_distance

        self.cosine_distance_dict[user_name] = cosine_distance_dict

    def makeRecommendation(self, user_name, topn_recommendation=10):

        if user_name not in self.cosine_distance_dict:
            self.ldaCosineDistance(user_name)

        user_recommendations = self.cosine_distance_dict[user_name]

        n = 0
        for recommendation, cosine_distance in sorted(
                user_recommendations.items(), key=lambda x: x[1]):
            print((recommendation, cosine_distance))
            n += 1
            if n == topn_recommendation:
                break

        return user_recommendations

    def showTopic(self, topic_number, topn_word=5):
        """
        topic_numer:
            which topic to show
        topn_word:
            show top n words in this topic
        """

        print(u'{:20} {}'.format(u'term', u'frequency') + u'\n')

        for term, frequency in self.lda.show_topic(topic_number, topn_word):
            print(u'{:20} {:.3f}'.format(term, round(frequency, 3)))

    def showUserTopic(self, user_name, topn_word=10):
        if user_name not in self.corp_bow:
            print('no such user! please check the screen name')
            return

        user_bow = self.corp_bow[user_name]

        user_lda = self.lda[user_bow]

        user_lda = sorted(user_lda, key=lambda x: -x[1])

        for topic_number, freq in user_lda:

            print('topic number {}  {}'.format(topic_number, freq))
            print('|____')
            self.showTopic(topic_number, topn_word)
            print('\n')