Return information about an organization
179129
def api_orga(request, orgaPk, key=None, hproPk=None):
    """"""

    if not check_api_key(request, key, hproPk):
        return HttpResponseForbidden

    retour = {}

    if settings.PIAPI_STANDALONE:
        retour['pk'] = orgaPk
        if orgaPk == "-1":
            retour['name'] = 'EBU'
            retour['codops'] = 'zzebu'
        if orgaPk == "-2":
            retour['name'] = 'RTS'
            retour['codops'] = 'chrts'
        if orgaPk == "-3":
            retour['name'] = 'BBC'
            retour['codops'] = 'gbbbc'
        if orgaPk == "-4":
            retour['name'] = 'CNN'
            retour['codops'] = 'uscnn'

    else:
        from organizations.models import Organization

        orga = get_object_or_404(Organization, pk=orgaPk)

        retour['pk'] = orga.pk
        retour['name'] = orga.name
        retour['codops'] = orga.ebu_codops

    return HttpResponse(json.dumps(retour), content_type="application/json")
80164
def _get_info(self, item, check_not_on_or_after=True):
        
        timestamp = item["timestamp"]

        if check_not_on_or_after and not time_util.not_on_or_after(timestamp):
            raise ToOld()

        try:
            return item["info"]
        except KeyError:
            return None
289711
function (subject) {
    var t = kb.findTypeURIs(subject)
    if (t[ns.vcard('Individual').uri]) return 'Contact'
    if (t[ns.vcard('Organization').uri]) return 'contact'
    if (t[ns.foaf('Person').uri]) return 'Person'
    if (t[ns.schema('Person').uri]) return 'Person'
    if (t[ns.vcard('Group').uri]) return 'Group'
    if (t[ns.vcard('AddressBook').uri]) return 'Address book'
    return null // No under other circumstances
  }
1002069
def get_member_brief(self, member_id=0):

        ''' 
        '''

    # https://www.meetup.com/meetup_api/docs/members/:member_id/#get

        title = '%s.get_member_brief' % self.__class__.__name__

    # validate inputs
        input_fields = {
            'member_id': member_id
        }
        for key, value in input_fields.items():
            if value:
                object_title = '%s(%s=%s)' % (title, key, str(value))
                self.fields.validate(value, '.%s' % key, object_title)

    # construct request fields
        url = '%s/members/' % self.endpoint
        params = {
            'member_id': 'self'
        }
        if member_id:
            params['member_id'] = member_id

    # send request
        response_details = self._get_request(url, params=params)

    # construct method output dictionary
        profile_details = {
            'json': {}
        }
        for key, value in response_details.items():
            if not key == 'json':
                profile_details[key] = value

    # parse response
        if response_details['json']:
            if 'results' in response_details['json'].keys():
                if response_details['json']['results']:
                    details = response_details['json']['results'][0]
                    for key, value in details.items():
                        if key != 'topics':
                            profile_details['json'][key] = value
        profile_details['json'] = self.objects.profile_brief.ingest(**profile_details['json'])

        return profile_details
601023
def info(self, id, attributes=None):
        
        if attributes:
            return self.call('customer.info', [id, attributes])
        else:
            return self.call('customer.info', [id])
724462
def get_organizations(self, permission='read'):
        # type: (str) -> List['Organization']
        
        success, result = self._read_from_hdx('user', self.data['name'], 'id', self.actions()['listorgs'],
                                              permission=permission)
        organizations = list()
        if success:
            for organizationdict in result:
                organization = hdx.data.organization.Organization.read_from_hdx(organizationdict['id'])
                organizations.append(organization)
        return organizations
863201
def info(id, options = {}, not_found = :reject, found = :return)
      @id = id
      @options = options
      custom_params = []
      custom_params << use_consistency(options)

      raw = send_get_request(@conn_no_err, ["/v1/acl/info/#{id}"], options, custom_params)

      if raw.status == 200 && raw.body.chomp != 'null'
        case found
        when :reject
          raise Diplomat::AclAlreadyExists, id
        when :return
          @raw = raw
          return parse_body
        end
      elsif raw.status == 200 && raw.body.chomp == 'null'
        case not_found
        when :reject
          raise Diplomat::AclNotFound, id
        when :return
          return nil
        end
      else
        raise Diplomat::UnknownStatus, "status #{raw.status}: #{raw.body}"
      end
    end
1158751
def organization_fields(self, organization):
        
        return self._query_zendesk(self.endpoint.organization_fields, 'organization_field', id=organization)
592478
def GetInfo(self):
        """"""
        return {
            'vendor': self.vendor,
            'product': self.product,
            'version': self.version,
            'url': self.url,
            'interfaces': list(self.interfaces.keys())
        }
1151916
def info(self):
        
        ddoc_info = self.r_session.get(
            '/'.join([self.document_url, '_info']))
        ddoc_info.raise_for_status()
        return response_to_json_dict(ddoc_info)
927014
def get_orgas(self):
        """"""

        r = self._request('orgas/')
        if not r:
            return None

        retour = []

        for data in r.json()['data']:
            o = Orga()
            o.__dict__.update(data)
            o.pk = o.id

            retour.append(o)

        return retour
1207601
def get_group_info(self, steamID):
        """"""
        url = self.create_request_url(self.GROUP, steamID)
        data = self.retrieve_request(url)
        return self.return_data(data, format='xml')
119743
def info(self, params=None):
        ''' 
        '''
        params = params if params else dict()
        return self.request('/v1/account/info', params, 'GET')
284647
def info(gandi, email):
    """"""
    login, domain = email

    output_keys = ['login', 'aliases', 'fallback', 'quota', 'responder']
    mailbox = gandi.mail.info(domain, login)
    output_mailbox(gandi, mailbox, output_keys)

    return mailbox
432924
def get_info(self):
        
        info = {
            "name":     self.name,
            "mode":     self.mode & 0o7777,
            "uid":      self.uid,
            "gid":      self.gid,
            "size":     self.size,
            "mtime":    self.mtime,
            "chksum":   self.chksum,
            "type":     self.type,
            "linkname": self.linkname,
            "uname":    self.uname,
            "gname":    self.gname,
            "devmajor": self.devmajor,
            "devminor": self.devminor
        }

        if info["type"] == DIRTYPE and not info["name"].endswith("/"):
            info["name"] += "/"

        return info
612521
def info():
    """"""
    print("convenience function for listing prms")
    print(type(prms))
    print(prms.__name__)
    print(f"prm file: {_get_prm_file()}")

    for key in prms.__dict__:
        if isinstance(prms.__dict__[key], box.Box):
            print()
            print(80 * "=")
            print(f"prms.{key}:")
            print(80 * "-")
            for subkey in prms.__dict__[key]:
                print(
                    f"prms.{key}.{subkey} = ",
                    f"{prms.__dict__[key][subkey]}"
                )
            print(80 * "=")
17510
def get_info(self, location):
        """"""
        assert not location.rstrip('/').endswith(self.dirname), 'Bad directory: %s' % location
        output = call_subprocess(
            [self.cmd, 'info', location], show_stdout=False, extra_environ={'LANG': 'C'})
        match = _svn_url_re.search(output)
        if not match:
            logger.warn('Cannot determine URL of svn checkout %s' % display_path(location))
            logger.info('Output that cannot be parsed: \n%s' % output)
            return None, None
        url = match.group(1).strip()
        match = _svn_revision_re.search(output)
        if not match:
            logger.warn('Cannot determine revision of svn checkout %s' % display_path(location))
            logger.info('Output that cannot be parsed: \n%s' % output)
            return url, None
        return url, match.group(1)