예제 #1
0
    def lookup_location_lat_lon(vars):
        print "mid", vars["mid"]
        import freebase

        result = freebase.mqlread(
            {
                "mid": vars["mid"],
                "type": "/location/location",
                "/location/location/geolocation": {"latitude": None, "longitude": None},
            }
        )
        if result:
            return result["/location/location/geolocation"]
        else:
            # the first thing didn't match, maybe see if it is containedby something that has a geolocation
            # this isn't necessarily the best thing to do, but it seems to work for now
            result = freebase.mqlread(
                {
                    "mid": vars["mid"],
                    "type": "/location/location",
                    "/location/location/containedby": [
                        {
                            "/location/location/geolocation": {"latitude": None, "longitude": None},
                            "/location/location/area": None,
                            "sort": "/location/location/area",
                            "limit": 1,
                        }
                    ],
                }
            )
            if result:
                return result["/location/location/containedby"][0]["/location/location/geolocation"]
            else:
                raise Exception("location not found")
예제 #2
0
 def lookup_location_lat_lon(vars) :
   print 'mid', vars['mid']
   import freebase
   result = freebase.mqlread({
     "mid" : vars['mid'],
     "type" : "/location/location",
     "/location/location/geolocation" : {
       "latitude" : None,
       "longitude" : None,
     },
   })
   if result :
     return result['/location/location/geolocation']
   else :
     # the first thing didn't match, maybe see if it is containedby something that has a geolocation
     # this isn't necessarily the best thing to do, but it seems to work for now
     result = freebase.mqlread({
       "mid" : vars['mid'],
       "type" : "/location/location",
       "/location/location/containedby" : [{
         "/location/location/geolocation" : {
           "latitude" : None,
           "longitude" : None,
         },
         "/location/location/area" : None,
         "sort" : "/location/location/area",
         "limit" : 1,
       }],
     })
     if result :
       return result['/location/location/containedby'][0]['/location/location/geolocation']
     else :
       raise Exception('location not found')
예제 #3
0
  def get(self):
    VIEW = "?id="
    BASE = "http://api.freebase.com/api/trans/image_thumb"
    OPTIONS = "?maxheight=300"
    
    id = cgi.escape(self.request.get('id'))

    if id != "":
        info_query = {
            "id" : id,
            "name" : None,    
        }
    
        info = freebase.mqlread(info_query)
        
        user = users.get_current_user()
        search = Search()
        if user:
            search.author = user
        search.id = id
        search.name = info.name
        search.url = VIEW + id
        search.put()
        
    
        query = {
            "id": id,
            "/type/reflect/any_reverse": [{
              "id" : None,
              "/common/topic/image": [{
                "id":       None,
                "optional": True,
                "limit": 5
              }]
            }]
        }
        results = freebase.mqlread(query)
        images = dict()
        for thing in results["/type/reflect/any_reverse"]:
            imgroup = thing['/common/topic/image']
            if len(imgroup) > 0:
                for image in imgroup:
                    images[VIEW + thing["id"]] = BASE + image['id'] + OPTIONS
    
        #template_values = {"images": images}
        #path = os.path.join(os.path.dirname(__file__), 'images.html')
        #self.response.out.write(template.render(path, template_values))
    
        final = ""
        for page, image in images.items():
            final += "<a href='" + page + "'><img src='" + image + "' alt='' /></a>"
        if len(final) == 0:
            final = "Sorry, there are no images to show."
        self.response.out.write(final)
예제 #4
0
    def test_mqlreaditer(self):
        filmq = [{"id": None, "initial_release_date>=": "2009", "name": None, "type": "/film/film"}]
        r0 = freebase.mqlreaditer(filmq)
        r1 = freebase.mqlreaditer(
            filmq[0]
        )  # The difference between [{}] and []. mqlreaditer should be able to handle both
        self.assertNotEqual(r0, None)
        self.assertEqual([a for a in r0], [b for b in r1])

        # and let's test it for mqlread, just in case
        # actually, for mqlread, it must be [{}], because there are lots of elements
        m0 = freebase.mqlread(filmq)
        m1 = lambda: freebase.mqlread(filmq[0])
        self.assertRaises(MetawebError, m1)
        self.assertNotEqual(m0, None)
예제 #5
0
    def GetType(self, keyword):
        if not keyword:
            return [[], []]
        #search for the id
        data = freebase.search(keyword, limit=1)
        if not data:
            return [[], []]
        item_id = [d['id'] for d in data if 'id' in d][0]
        query = {"id": item_id, "type": [{}]}
        response = freebase.mqlread(query)
        types = response['type']

        names = []
        base_names = []
        for k in types:
            names.append(k['name'])
            type_x = ''.join(k['id']).split('/')
            if len(type_x) > 1:
                base_names.append(type_x[1])
        names_set = set(names)
        base_names_set = set(base_names)
        names = []
        base_names = []
        for y in names_set:
            names.append(y)
        for y in base_names_set:
            base_names.append(y)

        all_list = []
        all_list.append(names)
        all_list.append(base_names)
        return all_list
예제 #6
0
파일: views.py 프로젝트: wolet/meccid
def view_page(request, page_id):
    try:
        post = BlogPost.objects.get(pk = page_id)
    except BlogPost.DoesNotExist:
        raise Http404
    baseT = ThreadedComment.objects.get(pk = post.baseThreadID)

    baseSet = ThreadedComment.objects.filter(tree_path__contains = ('%010i' % int(baseT.comment_ptr_id)))

    newSet = ThreadedComment.objects.filter(tree_path__contains = ('%010i' % int(baseT.comment_ptr_id)))
    newSet = newSet.order_by('-submit_date')
    latestTC = newSet[0]


    post.postNumComments = baseSet.count() -1
    post.save()
    postSet = BlogPost.objects.filter(pk = page_id)

    tagSet = list()
    try:
        tups = TagUserPost.objects.filter(post =  post)
        for tup in tups:
            tag = Tag.objects.get(pk = tup.tag.mid)
            tagSet.append(tag)
        imageID = "NULL"
        if len(tagSet)>0:
            headTag = tagSet[0]
            query=[{"mid":headTag.mid,"/common/topic/image" : [{"id" : None,"optional": True}]}]
            result = freebase.mqlread(query,extended=True)
            if(len(result[0]["/common/topic/image"]))>0:
                imageID = result[0]["/common/topic/image"][0]["id"]
    except TagUserPost.DoesNotExist:
        pass
    
    return render_to_response( "view_page.html", {"post":post, "postSet": postSet ,'base' : baseSet,'user' : request.user, 'tags' : tagSet,'latestTC' : latestTC.comment_ptr_id,'imageID': imageID},context_instance = RequestContext(request))
예제 #7
0
    def get(self):
        # Get username
        username = self.request.get("username")
        # Get top 50 albums from last.fm
        lastFMurl = (
            "http://ws.audioscrobbler.com/2.0/?method=user.gettopartists&"
            + urllib.urlencode({"user": username})
            + "&api_key=b25b959554ed76058ac220b7b2e0a026"
        )
        lastFMresponse = urlfetch.fetch(lastFMurl)
        lastFMdom = xml.dom.minidom.parseString(lastFMresponse.content)

        # If username not found, return error message
        if len(lastFMdom.getElementsByTagName("artist")) == 0:
            self.response.out.write(
                simplejson.dumps({"failure": "No Last.FM user by the username:"******"artist"):
            names.append(artist.getElementsByTagName("name")[0].childNodes[0].data.encode("ascii", "ignore"))
        # Fidn artist by name in metabase
        mqlQuery = [
            {
                "type": "/music/artist",
                "/common/topic/image": [{"id": None, "limit": 1}],
                "name": None,
                "name|=": names,
                "origin": [{"name": None, "geolocation": [{"latitude": None, "longitude": None}]}],
            }
        ]
        mqlResult = freebase.mqlread(mqlQuery)
        self.response.out.write(simplejson.dumps(mqlResult))
예제 #8
0
def freebase_id_from_parl_id():
    import freebase
    import time
    for info in PoliticianInfo.sr_objects.filter(schema='parl_id').order_by('value'):
        if PoliticianInfo.objects.filter(politician=info.politician, schema='freebase_id').exists():
            continue
        query = {
            'type': '/base/cdnpolitics/member_of_parliament',
            'id': [],
            'key': {
                'namespace': '/source/ca/gov/house',
                'value': info.value
            }
        }
        result = freebase.mqlread(query)
        print "result: %s" % result
        #time.sleep(1)
        if not result:
            try:
                print "Nothing for %s (%s)" % (info.value, info.politician)
            except:
                pass
        else:
            freebase_id = result['id'][0]
            PoliticianInfo(politician=info.politician, schema='freebase_id', value=freebase_id).save()
            print "Saved: %s" % freebase_id
예제 #9
0
def queryCityTown(taxonomy, tourist_locations):
    logger.debug('queryCityTown')
    logger.debug(strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime()))
    
    query = [{ 
              "type": "/location/citytown", 
              "name": None,
              "id":None,
              "limit": 10,
              "/common/topic/alias": [],
              "/common/topic/image": [{
                                       "id": None, 
                                       "optional": True,
                                       "/common/image/size": {
                                                       "/measurement_unit/rect_size/x" : None,
                                                       "/measurement_unit/rect_size/y" : None
                                        }
                                     }] 
            }]
    
    if fwiki.settings.DEBUG == True:
        print 'in test mode'
        r = freebase.mqlread(query)
    else:
        print 'in production mode'
        count = 0
        while count < 3 :
            try:
                r = freebase.mqlreaditer(query)
                break
            except:
                count += 1
                
    for i in r:            
        buildTBranch(i,taxonomy,tourist_locations)
예제 #10
0
def getBoardMemberships(id=None, name=None):
    """Get al boardmemberships for a person."""

    qGetBoardMemberships = {
        "/business/board_member/organization_board_memberships": [{
            "/organization/organization_board_membership/organization": {
                "id": None,
                "name": None
            }
        }],
        "id":
        None,
        "name":
        None,
        "type":
        "/business/board_member"
    }

    qGetBoardMemberships['id'] = id
    qGetBoardMemberships['name'] = name

    result = fb.mqlread(qGetBoardMemberships)
    companies = {}

    for m in result['/business/board_member/organization_board_memberships']:
        cid = m['/organization/organization_board_membership/organization'][
            'id']
        clbl = m['/organization/organization_board_membership/organization'][
            'name']
        companies[cid] = clbl

    rootnode = {result['id']: result['name']}

    return (rootnode, companies)
예제 #11
0
    def query_parser(item_id):
        # summary, photo and properties
        query[0]['source']['id'] = item_id
        response = freebase.mqlread(query)

        summary = ''
        image = ''
        name = ''
        more_url = ''
        # key:string value:dedup list
        properties = {}
        t_format_summary = None
        t_format_wikiurl = Format_WikiURL(item_id)
        t_format_wikiurl.start()

        for r in response:
            # summary
            if r['master_property'][0]['id'] == '/common/topic/article':
                t_format_summary = Format_Summary(r['target'][0]['id'])
                t_format_summary.start()
            # image
            elif r['master_property'][0]['id'] == '/common/topic/image':
                image = format_image(r['target'][0]['id'])
            # properties
            else:
                if r['target_value'] and r['target_value'][0]:
                    if r['master_property'][0]['name'] == 'Name':
                        if r['target'][0]['name'] != 'English':
                            continue
                    properties = format_properties(properties, r['master_property'][0]['name'], r['target_value'][0]['value'])
                elif r['target'] and r['target'][0]:
                    properties = format_properties(properties, r['master_property'][0]['name'], r['target'][0]['name'])
                else:
                    properties = format_properties(properties, r['master_property'][0]['name'], '')

        if t_format_summary:
            t_format_summary.join()
            t_format_wikiurl.join()
            if t_format_summary.result:
                summary = t_format_summary.result

            if t_format_wikiurl.result:
                more_url = t_format_wikiurl.result

            if 'Name' in properties:
                name = properties.pop('Name')[0]
            if 'Permission' in properties:
                properties.pop('Permission')
            if 'Type' in properties:
                properties.pop('Type')
            if 'Hero image ID' in properties:
                properties.pop('Hero image ID')
        else:
            summary = ''
            image = ''
            name = ''
            more_url = ''
            properties = {}

        return summary, image, name, more_url, properties
예제 #12
0
 def GetType(self, keyword):
     if not keyword:
         return [[],[]]
     #search for the id
     data = freebase.search(keyword, limit=1)
     if not data:
         return [[],[]]
     item_id = [d['id'] for d in data if 'id' in d][0]
     query = {"id":item_id, "type":[{}]}
     response = freebase.mqlread(query)
     types = response['type']
     
     names = []
     base_names = []
     for k in types:
         names.append(k['name'])
         type_x = ''.join(k['id']).split('/');
         if len(type_x)>1:
             base_names.append(type_x[1])
     names_set = set(names)
     base_names_set = set(base_names)
     names = []
     base_names = []
     for y in names_set:
         names.append(y)
     for y in base_names_set:
         base_names.append(y)
         
     all_list = []
     all_list.append(names)
     all_list.append(base_names)
     return all_list
예제 #13
0
 def test_mqlreaditer(self):
     filmq = [{'id': None,
                 'initial_release_date>=': '2009',
                 'name': None,
                 'type': '/film/film'
                 }]
     r0 = freebase.mqlreaditer(filmq)
     r1 = freebase.mqlreaditer(filmq[0]) # The difference between [{}] and []. mqlreaditer should be able to handle both
     self.assertNotEqual(r0, None)
     self.assertEqual([a for a in r0], [b for b in r1])
     
     # and let's test it for mqlread, just in case
     # actually, for mqlread, it must be [{}], because there are lots of elements
     m0 = freebase.mqlread(filmq)
     m1 = lambda : freebase.mqlread(filmq[0])
     self.assertRaises(MetawebError, m1)
     self.assertNotEqual(m0, None)
예제 #14
0
    def lookup_albums_by_musician(vars):
        import freebase

        result = freebase.mqlread(
            {"mid": vars["artist_mid"], "type": "/music/artist", "album": [{"name": None, "mid": None}]}
        )
        # print result
        return result["album"]
예제 #15
0
    def lookup_birthplace(vars):
        import freebase

        result = freebase.mqlread(
            {"mid": vars["person_mid"], "type": "/people/person", "place_of_birth": {"mid": None, "name": None}}
        )
        # print result
        return result["place_of_birth"]
예제 #16
0
    def test_unsafe(self):
        kurt = "/en/kurt_vonnegut"

        self.assertRaises(MetawebError, lambda: freebase.unsafe(kurt))

        r = freebase.mqlread({"id": kurt, "/common/topic/article": [{"id": None, "optional": True, "limit": 1}]})
        unsafe = freebase.unsafe(r["/common/topic/article"][0].id)
        self.assertNotEqual(len(unsafe), 0)
예제 #17
0
 def run(self):
     query = [{'id':'%s' % self.freebase_id, 'wiki_en:key':{'/type/key/namespace':'/wikipedia/en_id', 'value':None, 'optional':True}}]
     response = freebase.mqlread(query)
     if response[0] and 'wiki_en:key' in response[0]:
         wiki_id = str(response[0]['wiki_en:key']['value'])
         self.result = more_tag_template % wiki_id
     else:
         self.result = ''
예제 #18
0
 def test_unsafe(self):
     kurt = "/en/kurt_vonnegut"
     
     self.assertRaises(MetawebError, lambda: freebase.unsafe(kurt))
     
     r = freebase.mqlread({"id":kurt, "/common/topic/article":[{"id":None, "optional":True, "limit":1}]})
     unsafe = freebase.unsafe(r["/common/topic/article"][0].id)
     self.assertNotEqual(len(unsafe), 0)
예제 #19
0
    def test_ridiculously_long_write(self):
        
        q = [{
         "id":None,
         "id|=":["/guid/9202a8c04000641f80000000000" + str(a) for a in range(10000,10320)]
        }]

        self.assert_(len(str(q)), 1024)
        self.assertNotEqual(len(freebase.mqlread(q)), 0)
예제 #20
0
 def test_trans_image_thumb(self):
     kurt = "/en/kurt_vonnegut"
     
     r = freebase.mqlread({"id":kurt, "/common/topic/image":[{"id":None, "optional":True, "limit":1}]})
     imageid = r["/common/topic/image"][0].id
     rawimage = freebase.raw(imageid)
     
     thumbedimage = freebase.image_thumb(imageid, maxheight=99)
     self.assertNotEqual(rawimage, thumbedimage)
예제 #21
0
def queryDivisions(taxonomy, tourist_locations):
    logger.debug('queryDivisions')
    logger.debug(strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime()))
    query =[{
             "type":          "/location/administrative_division",
              "name":          None,
              "/common/topic/image" : [
                                       {
                                            "id": None,
                                            "optional" : True,
                                            "/common/image/size": {
                                                                   "/measurement_unit/rect_size/x" : None,
                                                                   "/measurement_unit/rect_size/y" : None
                                            }
                                        }
                                       ],
              "id":            None,
              "/common/topic/alias": [],
              "/location/location/containedby": [{
                "type":          "/location/country",
                "name":          None,
                "id":            None,
                "/common/topic/alias": [],
                "/location/location/containedby": [{
                  "type":          "/location/continent",
                  "optional":      True,
                  "name":          None,
                  "id":            None,
                  "/common/topic/alias": []
                }]
              }]
           }]
    count = 0
    
    if fwiki.settings.DEBUG == True:
        print 'in test mode'
        iter = freebase.mqlread(query)
    else:
        print 'in production mode'
        while count < 3 :
            try:
                iter = freebase.mqlreaditer(query)
                break
            except:
                count += 1
            
    for i in iter:
        contained_by = []
        for c in i[C_BY]:
            for cc in c[C_BY]:
                buildTBranch(cc, taxonomy, tourist_locations)
                contained_by.append(cc[NAME].lower())
                
            buildTBranch(c, taxonomy, tourist_locations, contained_by )
            contained_by.append(c[NAME].lower())
            
        buildTBranch(i,taxonomy,tourist_locations, contained_by)
예제 #22
0
    def test_trans_image_thumb(self):
        kurt = "/en/kurt_vonnegut"

        r = freebase.mqlread({"id": kurt, "/common/topic/image": [{"id": None, "optional": True, "limit": 1}]})
        imageid = r["/common/topic/image"][0].id
        rawimage = freebase.raw(imageid)

        thumbedimage = freebase.image_thumb(imageid, maxheight=99)
        self.assertNotEqual(rawimage, thumbedimage)
예제 #23
0
def wikipedia_from_freebase():
    import freebase

    for info in PoliticianInfo.sr_objects.filter(schema="freebase_id"):
        query = {"id": info.value, "key": [{"namespace": "/wikipedia/en_id", "value": None}]}
        result = freebase.mqlread(query)
        if result:
            # freebase.api.mqlkey.unquotekey
            wiki_id = result["key"][0]["value"]
            info.politician.set_info("wikipedia_id", wiki_id)
예제 #24
0
    def execute(self, query):
        import freebase

        fbResult = freebase.mqlread(query.freebaseQuery)

        result = {}

        for key in query.selectedKeys:
            result[key] = fbResult[key]

        return result
예제 #25
0
    def execute(self, query):
        import freebase

        fbResult = freebase.mqlread(query.freebaseQuery)

        result = {}

        for key in query.selectedKeys:
            result[key] = fbResult[key]

        return result
예제 #26
0
    def test_trans_raw(self):
        kurt = "/en/kurt_vonnegut"
        
        self.assertRaises(MetawebError, lambda: freebase.raw(kurt))
        
        r = freebase.mqlread({"id":kurt, "/common/topic/article":[{"id":None, "optional":True, "limit":1}]})
        raw = freebase.raw(r["/common/topic/article"][0].id)
        self.assertNotEqual(len(raw), 0)

        # trans should also work
        trans = freebase.trans(r["/common/topic/article"][0].id)
        self.assertEqual(trans, raw)
예제 #27
0
    def lookup_members_in_group(vars):
        # TODO: /music/musical_group/member doesn't have a name
        import freebase

        result = freebase.mqlread(
            {
                "mid": vars["mid"],
                "type": "/music/musical_group",
                "member": [{"/music/group_membership/member": {"mid": None, "name": None}}],
            }
        )
        return [member[u"/music/group_membership/member"] for member in result["member"]]
예제 #28
0
    def test_trans_raw(self):
        kurt = "/en/kurt_vonnegut"

        self.assertRaises(MetawebError, lambda: freebase.raw(kurt))

        r = freebase.mqlread({"id": kurt, "/common/topic/article": [{"id": None, "optional": True, "limit": 1}]})
        raw = freebase.raw(r["/common/topic/article"][0].id)
        self.assertNotEqual(len(raw), 0)

        # trans should also work
        trans = freebase.trans(r["/common/topic/article"][0].id)
        self.assertEqual(trans, raw)
예제 #29
0
 def lookup_albums_by_musician(vars) :
   import freebase
   result = freebase.mqlread({
     "mid" : vars['artist_mid'],
     "type" : "/music/artist",
     "album" : [{
       "name" : None,
       "mid" : None,
     }]
   })
   #print result
   return result['album']
예제 #30
0
 def lookup_birthplace(vars) :
   import freebase
   result = freebase.mqlread({
     "mid" : vars['person_mid'],
     "type" : "/people/person",
     "place_of_birth" : {
       "mid" : None,
       "name" : None,
     },
   })
   #print result
   return result['place_of_birth']
예제 #31
0
 def run(self):
     query = [
         {
             "id": "%s" % self.freebase_id,
             "wiki_en:key": {"/type/key/namespace": "/wikipedia/en_id", "value": None, "optional": True},
         }
     ]
     response = freebase.mqlread(query)
     if response[0] and "wiki_en:key" in response[0]:
         wiki_id = str(response[0]["wiki_en:key"]["value"])
         self.result = more_tag_template % wiki_id
     else:
         self.result = ""
예제 #32
0
파일: views.py 프로젝트: wolet/meccid
def sparql(request):

    token = list()
    if request.method == "POST":
#        fSession = HTTPMetawebSession("api.freebase.com")
        
        r = list()
        for tokenItem in request.POST.getlist('token'):
         query=[{"id": tokenItem, "mid":None, "/common/topic/notable_for": [{}],"name":[]   }]
         result = freebase.mqlread(query,extended=True)
        return render_to_response("sparql.html",{"list":r})

    return render_to_response("sparql.html",{})
예제 #33
0
 def test_freebase_dot_read(self):
     query = {'type':'/music/artist','guid':[{}],'name':'Sting', 'album':[{}]}
     
     result = freebase.mqlread(query)
     
     self.assertNotEqual(None, result)
     self.assert_(result.has_key('guid'))
     self.assert_(result.has_key('type'))
     self.assert_(result.has_key('name'))
     self.assert_(result.has_key('album'))
     self.assertEqual(type([]), type(result['album']))
     self.assert_(len(result['album']) > 0)
     self.assertEqual( 'Sting', result['name'])
     self.assertEqual('#9202a8c04000641f8000000000092a01', result['guid'][0]['value'])
예제 #34
0
    def test_freebase_dot_read(self):
        query = {"type": "/music/artist", "guid": [{}], "name": "Sting", "album": [{}]}

        result = freebase.mqlread(query)

        self.assertNotEqual(None, result)
        self.assert_(result.has_key("guid"))
        self.assert_(result.has_key("type"))
        self.assert_(result.has_key("name"))
        self.assert_(result.has_key("album"))
        self.assertEqual(type([]), type(result["album"]))
        self.assert_(len(result["album"]) > 0)
        self.assertEqual("Sting", result["name"])
        self.assertEqual("#9202a8c04000641f8000000000092a01", result["guid"][0]["value"])
예제 #35
0
 def lookup_members_in_group(vars) :
   # TODO: /music/musical_group/member doesn't have a name
   import freebase
   result = freebase.mqlread({
     "mid" : vars['mid'],
     "type" : '/music/musical_group',
     "member" : [{
       "/music/group_membership/member" : {
         "mid" : None,
         "name" : None,
       }
     }]
   })
   return [member[u'/music/group_membership/member'] for member in result['member']]
예제 #36
0
def parse_fb(self):
    createurs = Artiste.objects.all()
    for createur in createurs:
        try:
            print "Scanne l'artiste "+str(createur.name_id).encode('<utf-8>')
            requete = {
                       "type": "/people/person",
                       "name": createur.name.encode('<utf8>'),
                       "date_of_birth" : None,
                       "place_of_birth" : None,
                       '/common/topic/description' : None,
                       '/common/topic/official_website' : [{}],
                       '/common/topic/topic_equivalent_webpage' : [{}],
                       "profession" : []
                       }
            essai = freebase.mqlreaditer(requete, asof=None)
            reponses = 0
            if essai is not None:
                for i in essai:
                    reponses = reponses+1
                print "Freebase trouve "+str(reponses).encode('<utf-8>')+" réponses pour ce créateur"
            if reponses==1:
                print "debut de collecte des informations"
                i = freebase.mqlread(requete, asof=None)
    
                if i["date_of_birth"] is not None and createur.date_naissance is None:
                    birth = i['date_of_birth']
                    birth = birth.split('-')
                    if len(birth)==1:
                        createur.date_naissance = datetime.datetime(int(birth[0]), 1, 1, 0, 0)
                    else:
                        createur.date_naissance = datetime.datetime(int(birth[0]), int(birth[1]), int(birth[2]), 0, 0)
                
                if i["place_of_birth"] is not None and createur.lieu_naissance is None:
                    createur.lieu_naissance = i['place_of_birth']
                    
                #chopper le site perso
                if len(i['/common/topic/official_website'])>0:
                    url1 = i['/common/topic/official_website'][0]['value']
                    test = LienWeb.objects.filter(URL = url1)
                    if len(test) == 0:
                        siteweb = LienWeb(URL = url1)
                        siteweb.name = "site personnel de "+str(createur.name)
                        siteweb.save()
                        createur.productions_web.add(siteweb)
                createur.save()
                print "fini de chercher dans freebase pour "+str(createur.name_id).encode('<utf-8>')
        except:
            print "probleme avec l'artiste "+str(createur.name_id).encode('<utf-8>')
예제 #37
0
def wikipedia_from_freebase():
    import freebase
    for info in PoliticianInfo.sr_objects.filter(schema='freebase_id'):
        query = {
            'id': info.value,
            'key': [{
                'namespace': '/wikipedia/en_id',
                'value': None
            }]
        }
        result = freebase.mqlread(query)
        if result:
            # freebase.api.mqlkey.unquotekey
            wiki_id = result['key'][0]['value']
            info.politician.set_info('wikipedia_id', wiki_id)
예제 #38
0
    def get_types(self):
        '''docs'''
        if not self.keyword:
            return None

        # search for the id
        data = freebase.search(self.keyword, limit=1)
        if data:
            item_id = [d['id'] for d in data if 'id' in d][0]

            query = {"id": item_id, "type": [{}], 'key': [], 'name': None}
            response = freebase.mqlread(query)

            return self.entity_builder(response)
        else:
            return None
예제 #39
0
    def get_types(self):
        '''docs'''
        if not self.keyword:
            return None

        # search for the id
        data = freebase.search(self.keyword, limit=1)
        if data:
            item_id = [d['id'] for d in data if 'id' in d][0]

            query = {"id":item_id, "type":[{}], 'key':[], 'name':None}
            response = freebase.mqlread(query)
            
            return self.entity_builder(response)
        else:
            return None
예제 #40
0
    def get(self):
        # Get username
        username = self.request.get("username")
        # Get top 50 albums from last.fm
        lastFMurl = 'http://ws.audioscrobbler.com/2.0/?method=user.gettopartists&' + urllib.urlencode(
            {'user': username}) + '&api_key=b25b959554ed76058ac220b7b2e0a026'
        lastFMresponse = urlfetch.fetch(lastFMurl)
        lastFMdom = xml.dom.minidom.parseString(lastFMresponse.content)

        # If username not found, return error message
        if len(lastFMdom.getElementsByTagName('artist')) == 0:
            self.response.out.write(
                simplejson.dumps({
                    'failure':
                    'No Last.FM user by the username:'******'artist'):
            names.append(
                artist.getElementsByTagName('name')
                [0].childNodes[0].data.encode('ascii', 'ignore'))
        # Fidn artist by name in metabase
        mqlQuery = [{
            'type':
            '/music/artist',
            "/common/topic/image": [{
                "id": None,
                "limit": 1
            }],
            'name':
            None,
            'name|=':
            names,
            "origin": [{
                "name": None,
                "geolocation": [{
                    "latitude": None,
                    "longitude": None
                }]
            }]
        }]
        mqlResult = freebase.mqlread(mqlQuery)
        self.response.out.write(simplejson.dumps(mqlResult))
예제 #41
0
def retrieve_freebase_desc(name, stype):
    if not freebase:
        return ""

    print "Retrieving the description for %s" % name

    fb_type = settings.FREEBASE_TYPE_MAPPINGS.get(stype, None)
    value, data = None, ""
    try:
        value = freebase.mqlread({"name": name, "type": fb_type or [], FREEBASE_DESC_KEY: [{"id": None}]})
    except:
        try:
            values = freebase.mqlreaditer({"name": name, "type": fb_type or [], FREEBASE_DESC_KEY: [{"id": None}]})
            value = values.next()
        except Exception, e:
            # Only print error as freebase is only optional
            if settings.ST_DEBUG:
                print "Error using `freebase`: %s" % e
예제 #42
0
파일: jgd2.py 프로젝트: H1ghT0p/jgd
    def filter(self, prop, ids, rhs, reverse=False):
        id_or_equals = set()
        if reverse:
            prop = "!%s" % prop
        for nodenum, fbid in ids:
            id_or_equals.add(fbid)
        query = {"id" : null, "id|=": list(id_or_equals)}
        query[prop] = rhs
        result = freebase.mqlread([query])
        out_set = set()
        out_data = {}
        for r in result:
            r_id = r["id"]
            for nodenum, fbid in ids:
                if fbid == r_id:
                    out_set.add(nodenum)
                    out_data[nodenum] = r[prop]

        return (out_set, out_data)
예제 #43
0
def retrieve_freebase_name(name, stype):
    if not freebase:
        return name

    search_key = fix_name_for_freebase(name)
    fb_type = settings.FREEBASE_TYPE_MAPPINGS.get(stype, None)
    value = None
    try:
        # Try to get the exact match
        value = freebase.mqlread({"name": None, "type": fb_type or [], "key": {"value": search_key}})
    except:
        try:
            # Try to get a results has a generator and return its top result
            values = freebase.mqlreaditer({"name": None, "type": fb_type or [], "key": {"value": search_key}})
            value = values.next()
        except Exception, e:
            # Only print error as freebase is only optional
            if settings.ST_DEBUG:
                print "Error using `freebase`: %s" % e
def ensure_freebase_ids_are_guids():
    for species in Species.objects.exclude(freebase_id__startswith='/guid/'):
        guid = freebase.mqlread({
            'id': species.freebase_id,
            'guid': None
        })['guid']
        
        new_freebase_id = '/guid/%s' % guid[1:]
        # Does that guid already exist? If so, a merge is needed
        if Species.objects.filter(freebase_id = new_freebase_id):
            dupe = Species.objects.get(freebase_id = new_freebase_id)
            print "Duplicate: %s:%s and %s:%s - you must fix that first" % (
                species.pk, species.slug, dupe.pk, dupe.slug
            )
            continue
        
        species.freebase_id = new_freebase_id
        species.save()
        print "    %s freebase id is now %s" % (species, new_freebase_id)
예제 #45
0
def getBGGIDFromFB(game_id):
    """Returns the Board Game Geek Game ID and Freebase MID from Freebase.    
    """
    # This query will return None if there is no BGG key/id.
    query = {
      "id":            str(game_id),
      "mid":           None,
      "key" : {
        "namespace" : "/user/pak21/boardgamegeek/boardgame",
        "value" : None,
        "optional": True
      }
    }  
    result = freebase.mqlread(query, extended=True)
    if result.key is not None: # The FB game entry has a BGG id
        game_ids = {"bgg_id":result.key.value, "mid":result.mid}  
        logging.info(TRACE+'getBGGIDFromFB():: bgg_id = ' +game_ids["bgg_id"])  
        return game_ids
    else:
        game_ids = {"bgg_id":None, "mid":result.mid}
        logging.info(TRACE+'getBGGIDFromFB():: bgg_id = None')         
        return game_ids   
예제 #46
0
파일: Scraper.py 프로젝트: beagan/rankfavs
def getFreebaseData(source,value):
	if source == "twitter":
		result = freebase.mqlread({"key": [{ "namespace": "/authority/twitter", "value": value}], 
											 "name": None, 
											 "/people/person/place_of_birth": None, 
											 "/people/person/nationality": [{}], 
											 "/people/person/date_of_birth": None, 
											 "/people/person/gender": None, 
											 "ns0:key": [{}]})
	elif source == 'wikipedia':
		result = freebase.mqlread({"key": [{ "namespace": "/wikipedia/en", "value": value}], 
											 "name": None, 
											 "/people/person/place_of_birth": None, 
											 "/people/person/nationality": [{}], 
											 "/people/person/date_of_birth": None, 
											 "/people/person/gender": None, 
											 "ns0:key": [{}]})
		if result == None:
			result = freebase.mqlread({"key": [{ "namespace": "/wikipedia/en_id", "value": value}], 
												 "name": None, 
												 "/people/person/place_of_birth": None, 
												 "/people/person/nationality": [{}], 
												 "/people/person/date_of_birth": None, 
												 "/people/person/gender": None, 
												 "ns0:key": [{}]})
		return result
	elif source == 'imdb':
		if 'http' in value:
			value = value.split('/name/')[1].split('/')[0]
		return freebase.mqlread({"key": [{ "namespace": "/authority/imdb/name", "value": value}], 
								 "name": None, 
								 "/people/person/place_of_birth": None, 
								 "/people/person/nationality": [{}], 
								 "/people/person/date_of_birth": None, 
								 "/people/person/gender": None, 
								 "ns0:key": [{}]})
	#make sure it was quotekey
	elif source == 'baseballalmanac':
		result = freebase.mqlread({"key": [{ "namespace": "/source/baseball_almanac/players", "value": value}], "name": None, "/people/person/place_of_birth": None, "/people/person/nationality": [{}], "/people/person/date_of_birth": None, "/people/person/profession": [{}], "/people/person/gender": None, "ns0:key": [{}] })
	###add checks to see if empty????
	elif source == 'name':
		return freebase.mqlread({"name": value, "/people/person/place_of_birth": None, "/people/person/nationality": [{}], "/people/person/date_of_birth": None, "/people/person/profession": [{}], "/people/person/gender": None, "ns0:key": [{}] })
	else:
		return None	
예제 #47
0
def getBoardMembers(id=None, name=None):
    """Return all the board members for a company."""

    # MQL query, in the form of a Python datastructure
    qGetBoardMembers = {
        "/organization/organization/board_members": [{
            "/organization/organization_board_membership/member": {
                "name": None,
                "id": None
            }
        }],
        "id":
        None,
        "name":
        None
    }

    # Assign the id and/or the name/label in the query
    qGetBoardMembers['id'] = id
    qGetBoardMembers['name'] = name

    result = fb.mqlread(qGetBoardMembers)

    # construct a tuple with two dictionaries (rootnode and related nodes)
    # a node has a { id : label } form
    persons = {}

    for p in result['/organization/organization/board_members']:
        pid = p['/organization/organization_board_membership/member']['id']
        plabel = p['/organization/organization_board_membership/member'][
            'name']
        persons[pid] = plabel

    rootnode = {result['id']: result['name']}

    return (rootnode, persons)
예제 #48
0
def freebase_id_from_parl_id():
    import freebase
    import time

    for info in PoliticianInfo.sr_objects.filter(schema="parl_id").order_by("value"):
        if PoliticianInfo.objects.filter(politician=info.politician, schema="freebase_id").exists():
            continue
        query = {
            "type": "/base/cdnpolitics/member_of_parliament",
            "id": [],
            "key": {"namespace": "/source/ca/gov/house", "value": info.value},
        }
        result = freebase.mqlread(query)
        print "result: %s" % result
        # time.sleep(1)
        if not result:
            try:
                print "Nothing for %s (%s)" % (info.value, info.politician)
            except:
                pass
        else:
            freebase_id = result["id"][0]
            PoliticianInfo(politician=info.politician, schema="freebase_id", value=freebase_id).save()
            print "Saved: %s" % freebase_id
예제 #49
0
def main():
    ''' docs '''
    # read in n3 file
    g.parse(INPUT, format='n3')
    fb_namespace = rdflib.namespace.Namespace('http://rdf.freebase.com/ns/')
    g.bind('freebase', 'http://rdf.freebase.com/ns/')

    # uncategorized terms
    f = open('uncategorized', 'w')

    for c in g.subject_objects(predicate=rdflib.term.URIRef(
            u'http://www.w3.org/2002/07/owl#equivalentClass')):
        if 'http://dbpedia.org/ontology/' in c[1]:
            freebase_type_added = False
            for cc in g.objects(
                    subject=c[0],
                    predicate=rdflib.term.URIRef(
                        u'http://www.w3.org/2002/07/owl#equivalentClass')):
                if 'http://rdf.freebase.com/ns/' in cc:
                    freebase_type_added = True
                    break

            if not freebase_type_added:
                #get the dbpedia type name
                dbpedia_type = c[1].replace('http://dbpedia.org/ontology/', '')
                searchet_type = c[0].replace(
                    'http://searchet.baidu.com/ontology#', '')
                freebase_guid = rclient.get(dbpedia_type)

                if freebase_guid:
                    # find the freebase type name
                    QUERY['guid'] = freebase_guid
                    fb_feedback = freebase.mqlread(QUERY)

                    # corresponding to id
                    freebase_type = ''
                    # corresponding to name
                    freebase_type_name = ''
                    if 'id' in fb_feedback:
                        freebase_type = '.'.join(
                            fb_feedback['id'].split('/')[1:])
                        freebase_type_name = fb_feedback['name']

                    # add freebase type to the ontology
                    if freebase_type:
                        if dbpedia_type != freebase_type_name or searchet_type != freebase_type_name:
                            print '%s // %s' % (dbpedia_type, freebase_type)
                            choice = raw_input('confirmed y/n?: ').lower()
                            if choice == 'y' or choice == 'yes':
                                g.add((
                                    c[0],
                                    rdflib.term.URIRef(
                                        u'http://www.w3.org/2002/07/owl#equivalentClass'
                                    ), fb_namespace[freebase_type]))
                                g.commit()
                            else:
                                freebase_found = freebase_limited_search(
                                    dbpedia_type)
                                candidate_type_names = [
                                    c['name'] for c in freebase_found
                                ]
                                if candidate_type_names:
                                    choice = raw_input(
                                        '[%s] enter nunber or \'no\': ' %
                                        ', '.join([
                                            '%s(%i)' % (t, i) for i, t in
                                            enumerate(candidate_type_names)
                                        ])).lower()
                                    # show all the types
                                    if choice != 'n' and choice != 'no':
                                        if 'type' in freebase_found[int(
                                                choice)]:
                                            for t in freebase_found[int(
                                                    choice)]['type']:
                                                print ': %s' % t['id']
                                    else:
                                        f.write('%s\n' % dbpedia_type)
                                    print
                                else:
                                    f.write('%s\n' % dbpedia_type)
                        else:
                            g.add((
                                c[0],
                                rdflib.term.URIRef(
                                    u'http://www.w3.org/2002/07/owl#equivalentClass'
                                ), fb_namespace[freebase_type]))
                            g.commit()
                else:  # cannot find a linked freebase type
                    freebase_found = freebase_limited_search(dbpedia_type)
                    candidate_type_names = [c['name'] for c in freebase_found]
                    if candidate_type_names:
                        print dbpedia_type
                        choice = raw_input(
                            '[%s] enter nunber or \'no\': ' % ', '.join([
                                '%s(%i)' % (t, i)
                                for i, t in enumerate(candidate_type_names)
                            ])).lower()
                        # show all the types
                        if choice != 'n' and choice != 'no':
                            if 'type' in freebase_found[int(choice)]:
                                for t in freebase_found[int(choice)]['type']:
                                    print ': %s' % t['id']
                        else:
                            f.write('%s\n' % dbpedia_type)
                        print
                    else:
                        f.write('%s\n' % dbpedia_type)
    f.close()
    g.serialize(destination=OUTPUT, format='n3', encoding='utf-8')
예제 #50
0
 def run(self):
     data = freebase.mqlread(self.query)
     # only one id is necessary
     if data and 'id' in data:
         self.result.append(data['id'][0]['value'])
예제 #51
0
query = [{
  "name": "Karl Popper",
    "guid": None,
      "type": "/influence/influence_node",
        "influenced": [{
	    "guid": None,
	        "name": None,
		    "type": "/influence/influence_node",
		        "influenced_by": [{
			      "type": "/people/person",
			            "guid": None,
				          "name": None,
					        "date_of_birth": None,
						      "nationality": [],
						            "religion": [],
							          "place_of_birth":[{
								          "name": None,
									          "/location/location/geolocation": {
										            "latitude" : None,
											              "longitude" : None
												              }
													            }]
														        }]
															  }]
															  }]

															  result = freebase.mqlread(query)
															  pprint(result,indent=1)

예제 #52
0
    def get_category(self, kwd):

        category = ""
        #FILM

        query1 = {
            "type": "/film/film",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        result1 = freebase.mqlread(query1)

        #FILM ACTOR
        query2 = {
            "type": "/film/actor",
            "name~=": "*" + kwd + "$",
            "return": "count"
        }
        result2 = freebase.mqlread(query2)

        #DIRECTOR
        query3 = {
            "type": "/film/director",
            "name~=": "*" + kwd + "$",
            "return": "count"
        }
        result3 = freebase.mqlread(query3)

        #CHARACTER
        query4 = {
            "type": "/film/character",
            "name~=": "*" + kwd + "$",
            "return": "count"
        }
        result4 = freebase.mqlread(query4)

        #SERIES
        query5 = {
            "type": "/film/series",
            "name~=": "*" + kwd + "$",
            "return": "count"
        }
        result5 = freebase.mqlread(query5)

        #PRODUCER
        query6 = {
            "type": "/film/producer",
            "name~=": "*" + kwd + "$",
            "return": "count"
        }
        result6 = freebase.mqlread(query6)

        #WRITER
        query7 = {
            "type": "/film/writer",
            "name~=": "*" + kwd + "$",
            "return": "count"
        }
        result7 = freebase.mqlread(query7)

        film_count = result1 + result2 + result3 + result4 + result5 + result6 + result7
        #import pdb;pdb.set_trace();
        #########################################################################################

        #BOOK
        query8 = {
            "type": "/book/book",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #result8 = freebase.mqlread(query8)

        query9 = {
            "type": "/book/short_story",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #result9 = freebase.mqlread(query9)

        query10 = {
            "type": "/book/book_character",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #result10 = freebase.mqlread(query10)

        #books_count = result8 +result9 + result10

        #######################PEOPLE#########################################

        query11 = {
            "type": "/people/person",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #result11 = freebase.mqlread(query11)

        #people_count = result11

        ################################PLACES########################33
        query12 = {
            "type": "/location/country",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #result12 = freebase.mqlread(query12)

        query13 = {
            "type": "/location/location",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #result13 = freebase.mqlread(query13)

        query14 = {
            "type": "/location/region",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #result14 = freebase.mqlread(query14)

        query15 = {
            "type": "/location/us_state",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #result15 = freebase.mqlread(query15)

        query16 = {
            "type": "/location/in_city",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #	result16 = freebase.mqlread(query16)

        query17 = {
            "type": "/location/in_state",
            "name~=": "*" + kwd + "*",
            "return": "count"
        }
        #	result17 = freebase.mqlread(query17)

        #	location_count = result12 + result13 + result14 + result15 + result16 +result17

        if film_count >= 1:
            category = "film"
        #if books_count >= 1 :
        #    category.append("books")
        #if people_count >= 1:
        #   category.append("people")
        #if location_count >= 1 :
        #   category.append("location")

        print category
        return category
예제 #53
0
db = connection.dataset_db
cursor1 = None

query_film = [{
    "type": "/film/film",
    #"film/actor":[],
    #"director":[],
    "/common/topic/article": {
        "id": None,
        "optional": True,
        "limit": 1
    },
    "name": [],
    "limit": lim
}]
results_film = freebase.mqlread(query_film)

query_book = [{
    "type": "/book/book",
    "/common/topic/article": {
        "id": None,
        "optional": True,
        "limit": 1
    },
    "name": [],
    "limit": lim
}]
results_book = freebase.mqlread(query_book)

query_people = [{
    "type": "/people/person",
예제 #54
0
 def get(self):
   
   query = { "id" : cgi.escape(self.request.get('id')), "name" : None} 
   r = freebase.mqlread(query)     
   self.response.out.write(r.name)