Retrieve the part that holds this Property.

        :returns: The :class:`Part` associated to this property
        :raises APIError: if the `Part` is not found
777104
def part(self):
        
        part_id = self._json_data['part']

        return self._client.part(pk=part_id, category=self._json_data['category'])
1326381
def partial(self, *args):
        
        def part(*args2):
            args3 = args + args2
            return self.obj(*args3)

        return self._wrap(part)
712597
def getPartitionList(self):
        
        if self._partList is None:
            self._partList = []
            for (disk,parts) in self.getPartitionDict().iteritems():
                for part in parts:
                    self._partList.append((disk,part))
        return self._partList
13470
def core_properties(self):
        
        try:
            return self.part_related_by(RT.CORE_PROPERTIES)
        except KeyError:
            core_props = CorePropertiesPart.default()
            self.relate_to(core_props, RT.CORE_PROPERTIES)
            return core_props
660556
def fetch_partial(self, container, obj, size):
        
        return self._manager.fetch_partial(container, obj, size)
707914
@Override
    public Collection<Part> getParts() throws IOException, ServletException {
        try {
            collaborator.preInvoke(componentMetaData);
            return request.getParts();
        } finally {
            collaborator.postInvoke();
        }
    }
398616
def get_owner(self, default=True):
        
        uid, gid = self.owner

        if not uid and default:
            uid = os.getuid()

        if not gid and default:
            gid = os.getgid()

        return uid, gid
646904
def get_object(self):
        
        queryset = self.get_queryset()             # Get the base queryset
        queryset = self.filter_queryset(queryset)  # Apply any filter backends
        filter = {}  # pylint: disable=W0622
        for field in self.lookup_fields:
            filter[field] = self.kwargs[field]
        return get_object_or_404(queryset, **filter)
1072094
def part(self, *args, **kwargs):
        
        return self._client.part(*args, bucket=self.bucket.get('id'), **kwargs)
377991
def relevant_part(self, original, pos, sep=' '):
        
        start = original.rfind(sep, 0, pos) + 1
        end = original.find(sep, pos - 1)
        if end == -1:
            end = len(original)
        return original[start:end], start, end, pos - start
813880
def get_current_object(self):
        
        if not hasattr(self.__local, '__release_local__'):
            return self.__local()
        try:
            return getattr(self.__local, self.__name__)
        except AttributeError:
            raise RuntimeError('no object bound to %s' % self.__name__)
1359626
def of(cls, part_class):
        
        copy = type(
            "VectorOf%s" % part_class.__name__,
            cls.__bases__, dict(cls.__dict__)
        )
        copy.item_class = part_class

        return copy
156578
def resource(self):
        
        if self._resource:
            return self._resource
        elif self.binding:
            return self.binding.resource
688340
def chart_part(self):
        
        rId = self._element.chart_rId
        chart_part = self.part.related_parts[rId]
        return chart_part
913477
def divisions(self):
        

        from .placeholder_division import PlaceholderDivision
        
        placeholder = None
        for item in self.__parts_and_divisions:
            if item.tag == 'part':
                if not placeholder:
                    placeholder = PlaceholderDivision()
                placeholder.parts.append(item)
            else:
                if placeholder:
                    yield placeholder
                    placeholder = None
                yield item
        if placeholder:
            yield placeholder
294512
def __parts_and_divisions(self):
        

        from .division import Division
        from .part import Part
        from .placeholder_part import PlaceholderPart

        text = self.node.text
        if text:
            stripped_text = text.replace('\n', '')
            if stripped_text.strip():
                yield PlaceholderPart(stripped_text)

        for item in self.node:
            if item.tag == 'part':
                yield Part(item)
            elif item.tag == 'div':
                yield Division(item)
            
            if item.tail:
                stripped_tail = item.tail.replace('\n', '')
                if stripped_tail.strip():
                    yield PlaceholderPart(stripped_tail)
617339
def get(self, prop):
        
        prop_parts = prop.split(".")
        val = None
        for part in prop_parts:
            if val is None:
                val = self.obj.get(part)
            else:
                val = val.get(part)
        return val