:return: e.g https://steamcommunity.com/profiles/123456789
        :rtype: :class:`str`
518473
def community_url(self):
        
        suffix = {
            EType.Individual: "profiles/%s",
            EType.Clan: "gid/%s",
        }
        if self.type in suffix:
            url = "https://steamcommunity.com/%s" % suffix[self.type]
            return url % self.as_64

        return None
1078681
def attrib(self):
        
        return dict([
            ('aValue', str(self.a_val)),
            ('bValue', str(self.b_val)),
            ('minMag', str(self.min_mag)),
            ('maxMag', str(self.max_mag)),
        ])
27804
def get_profiles(self, profile_base="/data/b2g/mozilla", timeout=None):
        

        rv = {}

        if timeout is None:
            timeout = self._timeout

        profile_path = posixpath.join(profile_base, "profiles.ini")
        try:
            proc = self.shell("cat %s" % profile_path, timeout=timeout)
            config = ConfigParser.ConfigParser()
            config.readfp(proc.stdout_file)
            for section in config.sections():
                items = dict(config.items(section))
                if "name" in items and "path" in items:
                    path = items["path"]
                    if "isrelative" in items and int(items["isrelative"]):
                        path = posixpath.normpath("%s/%s" % (profile_base, path))
                    rv[items["name"]] = path
        finally:
            proc.stdout_file.close()
            proc.stderr_file.close()

        return rv
59781
def attrib(self):
        
        return dict([
            ('probability', str(self.probability)),
            ('strike', str(self.strike)),
            ('dip', str(self.dip)),
            ('rake', str(self.rake)),
        ])
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')
510401
def page_str(self):
        
        tmpl = '.. _%s:\n\n%s\n\n%s\n\n----\n\n%s'
        components = (
            self._ms_name, self._page_title, self._intro_text,
            self._member_defs
        )
        return tmpl % components
1169107
def to_vars_dict(self):
        
        return {
            'gcloud_client_id':      self._client_id,
            'gcloud_client_secret':  self._client_secret,
            'gcloud_network':        self._network,
            'gcloud_project_id':     self._project_id,
            'gcloud_zone':           self._zone,
        }
415381
def profile(func):
    
    def _f(*args, **kwargs):
        print("\n<<<---")
        pr = cProfile.Profile()
        pr.enable()
        res = func(*args, **kwargs)
        p = pstats.Stats(pr)
        p.strip_dirs().sort_stats('cumtime').print_stats(20)
        print("\n--->>>")
        return res
    return _f
988791
def to_dict(self):
        
        return {'station_id': self.station_id,
                'timestamp': self.timestamp,
                'aggregated_on': self.aggregated_on,
                'temp': self.temp,
                'humidity': self.humidity,
                'wind': self.wind,
                'pressure': self.pressure,
                'precipitation': self.precipitation}
358779
def _repr_name(self):
        
        names = {"name", "attrname"}
        if all(name not in self._astroid_fields for name in names):
            return getattr(self, "name", getattr(self, "attrname", ""))
        return ""
760037
def to_string(self):
        
        return '%s   %s %s %s %s' % (
            self.trait, self.start_position, self.peak_start_position,
            self.peak_stop_position, self.stop_position)
898223
def get_user_info(self, steamID):
        """"""
        url = self.create_request_url(self.USER, steamID)
        data = self.retrieve_request(url)
        return self.return_data(data, format='xml')
258806
def get_user_classes(self):
        
        # Previously getting classes from profile (such a list is incomplete)
        # raw_classes = self.get_user_profile().get('all_classes').values()

        # Get classes from the user status (includes all classes)
        status = self.get_user_status()
        uid = status['id']
        raw_classes = status.get('networks', [])

        classes = []
        for rawc in raw_classes:
            c = {k: rawc[k] for k in ['name', 'term']}
            c['num'] = rawc.get('course_number', '')
            c['nid'] = rawc['id']
            c['is_ta'] = uid in rawc['prof_hash']
            classes.append(c)

        return classes
1231771
def getProfile(self):
        
        if self._create:
            return ObjectProfile()
        else:
            if self._profile is None:
                r = self.api.getObjectProfile(self.pid)
                self._profile = parse_xml_object(ObjectProfile, r.content, r.url)
            return self._profile
71965
def get_connection_cls(cls):
        
        if cls.__connection_cls is None:
            cls.__connection_cls, _ = cls.from_settings()
        return cls.__connection_cls
357897
def doc(self):
        
        doc = "Steam Web API - List of all interfaces\n\n"
        for interface in self.interfaces:
            doc += interface.__doc__
        return doc
406314
def profile_file(self):
        
        if 'profile' in self._kwargs and self._kwargs['profile']:
            profile_path = path.normpath(self._kwargs['profile'])
            if os.path.exists(profile_path) and os.path.isdir(profile_path):
                return path.join(
                    profile_path, '{}-{}.prof'.format(
                        os.getpid(), self._kwargs['consumer_name']))