Get the Streams instance that owns this view.

        Returns:
            Instance: Streams instance owning this view.
164603
def get_instance(self):
        
        return Instance(self.rest_client.make_request(self.instance), self.rest_client)
410623
def get_by_owner(cls, owner):
        
        return cls.query(cls.owner==cls._get_key(owner))
67209
def stream(stream_id, update_max_id = true)
      raise ArgumentError, "stream_id can't be 0" if stream_id == 0

      stream = @streams[stream_id]
      if stream
        if stream.state == :idle && stream_id < @max_stream_ids[stream_id % 2]
          stream.set_state(:closed_implicitly)
        end
      elsif stream_id > @max_stream_ids[stream_id % 2]
        @max_stream_ids[stream_id % 2] = stream_id if update_max_id
        stream = Stream.new(self, stream_id, state: :idle)
        callback(:stream, stream)
        @streams[stream_id] = stream
      else
        stream = Stream.new(self, stream_id, state: :closed_implicitly)
        callback(:stream, stream)
      end

      stream
    end
1332165
def load(self):
        
        stream = self.fs.load()
        stream = self.codec.decompress(stream)
        return stream
1271133
def metric_streaming(self):
        
        if not self.__metric_streaming:
            self.__metric_streaming = MetricStreaming(self.__connection)
        return self.__metric_streaming
226700
@NotNull
    @SuppressWarnings("unchecked")
    public Stream<T> stream() {
        if (!isPresent()) return Stream.empty();
        return Stream.of(value);
    }
430388
def get_event_stream(self):
        
        if self._event_stream is None:
            self._event_stream = WVAEventStream(self._http_client)
        return self._event_stream
766570
def get_instance(self, payload):
        
        return ChannelInstance(self._version, payload, service_sid=self._solution['service_sid'], )
101818
def items(self, *args, **kwargs):
        
        return self.get_stream()(self.get_object(*args, **kwargs))
1318959
def file(self, owner=None, **kwargs):
        
        return File(self.tcex, owner=owner, **kwargs)
542808
def get_view(self):
        
        view = self.view
        if not view.is_initialized:
            view.initialize()
        if not view.proxy_is_active:
            view.activate_proxy()
        return view.proxy.widget
1366578
def get_or_create_stream(self, stream_id, try_create=True):
        
        stream_id = get_stream_id(stream_id)
        if stream_id in self.streams:
            logging.debug("found {}".format(stream_id))
            return self.streams[stream_id]
        elif try_create:
            # Try to create the stream
            logging.debug("creating {}".format(stream_id))
            return self.create_stream(stream_id=stream_id)
320856
def get_streams(self):
        
        self._write_lock.acquire()
        try:
            return itervalues(self._stream_by_id)
        finally:
            self._write_lock.release()
115860
def sync_streams(self):
        
        if self._sync_streams is None:
            self._sync_streams = SyncStreamList(self._version, service_sid=self._solution['sid'], )
        return self._sync_streams
726630
def list_streams(self):
        
        # Server does not do pagination on listings of this resource.
        # Return an iterator anyway for similarity with other API methods
        path = '/archive/{}/streams'.format(self._instance)
        response = self._client.get_proto(path=path)
        message = rest_pb2.ListStreamsResponse()
        message.ParseFromString(response.content)
        streams = getattr(message, 'stream')
        return iter([Stream(stream) for stream in streams])
105520
def stream=(stream)
      logger = Logger.new(stream)
      logger.level = @logger.level
      logger.formatter = @logger.formatter
      @logger = logger
    end
1360188
def get_instance(self, payload):
        
        return SyncStreamInstance(self._version, payload, service_sid=self._solution['service_sid'], )