Issue a GET command

        Return a Deferred which fires with the size of the name being requested
972607
def get(self, name, mask=None):
        
        mypeer = self.transport.getQ2QPeer()
        tl = self.nexus.transloads[name]
        peerz = tl.peers
        if mypeer in peerz:
            peerk = peerz[mypeer]
        else:
            # all turned on initially; we aren't going to send them anything.
            peerk = PeerKnowledge(bits.BitArray(size=len(tl.mask), default=1))
            peerz[mypeer] = peerk
        peerk.sentGet = True
        return self.callRemote(
            Get, name=name, mask=mask).addCallback(lambda r: r['size'])
810255
def _get(self, *args, **kwargs):
        

        if 'timeout' not in kwargs:
            kwargs['timeout'] = self.timeout

        req = self.session.get(*args, **kwargs)
        return req
1206066
def fetch_size(self, v):
        

        if not isinstance(v, six.integer_types):
            raise TypeError
        if v == self._fetch_size:
            return self

        if v < 1:
            raise QueryException("fetch size less than 1 is not allowed")

        clone = copy.deepcopy(self)
        clone._fetch_size = v
        return clone
643008
def get(self, timeout=None):
        
        if not self.wait(timeout):
            raise TimeoutError("Result not available within %fs" % timeout)
        if self._success:
            return self._data
        raise self._data[0]
843234
def _get(operation: Operation, url=URL, **params):
    """"""
    prepped_request = _prep_get(operation, url=url, **params)
    return cgi.send(prepped_request)
184876
def calculate_size(name, permits, timeout):
    
    data_size = 0
    data_size += calculate_size_str(name)
    data_size += INT_SIZE_IN_BYTES
    data_size += LONG_SIZE_IN_BYTES
    return data_size
741204
def request_name(self, name, allow_replacement=True, replace=False):
		
		return NameOwner(self, name, allow_replacement, replace)
1030580
function getFn (req, res, next) {
    var reqPath = req.params[0];
    debug('getFn', 'reqPath', reqPath);

    stat(reqPath)
    .then(function (content) {
      if (!!content.type && content.type === 'file') {
        return res.sendFile(reqPath, { root: ramlPath });
      }
      res.status(200).json(content);
    }, function (err) {
      if (err === 'ENOENT') {
        return res.sendStatus(404);
      }
      next(err);
    });
  }
74766
async def get(self):
        
        if not self._deque:
            self._ready.clear()
            await self._ready.wait()

        buffer = io.BytesIO()
        batch = []
        size = 0

        # Fill a new batch to return while the size is small enough,
        # as long as we don't exceed the maximum length of messages.
        while self._deque and len(batch) <= MessageContainer.MAXIMUM_LENGTH:
            state = self._deque.popleft()
            size += len(state.data) + TLMessage.SIZE_OVERHEAD

            if size <= MessageContainer.MAXIMUM_SIZE:
                state.msg_id = self._state.write_data_as_message(
                    buffer, state.data, isinstance(state.request, TLRequest),
                    after_id=state.after.msg_id if state.after else None
                )
                batch.append(state)
                self._log.debug('Assigned msg_id = %d to %s (%x)',
                                state.msg_id, state.request.__class__.__name__,
                                id(state.request))
                continue

            if batch:
                # Put the item back since it can't be sent in this batch
                self._deque.appendleft(state)
                break

            # If a single message exceeds the maximum size, then the
            # message payload cannot be sent. Telegram would forcibly
            # close the connection; message would never be confirmed.
            #
            # We don't put the item back because it can never be sent.
            # If we did, we would loop again and reach this same path.
            # Setting the exception twice results in `InvalidStateError`
            # and this method should never return with error, which we
            # really want to avoid.
            self._log.warning(
                'Message payload for %s is too long (%d) and cannot be sent',
                state.request.__class__.__name__, len(state.data)
            )
            state.future.set_exception(
                ValueError('Request payload is too big'))

            size = 0
            continue

        if not batch:
            return None, None

        if len(batch) > 1:
            # Inlined code to pack several messages into a container
            data = struct.pack(
                '<Ii', MessageContainer.CONSTRUCTOR_ID, len(batch)
            ) + buffer.getvalue()
            buffer = io.BytesIO()
            container_id = self._state.write_data_as_message(
                buffer, data, content_related=False
            )
            for s in batch:
                s.container_id = container_id

        data = buffer.getvalue()
        return batch, data
1127157
function _getSafeFileName(filename, directory) {
        var deferred = q.defer();
    
        fs.readdir(directory, function(err, files) {
    
            if(err) {
              // This means the directory doesn't exist
              if (err.errno === 34 && err.code === 'ENOENT') {
                deferred.resolve(filename);
              }
              else {
                deferred.reject(err);
              }
            }
            else {
              var index = files.indexOf(filename);
              if (index > -1) { 
    
                // Get filename and extension (if it has one)
                var name, extension;
                var splitString = filename.split('.');
    
                // Has extension
                if (splitString.length > 1) {
                  extension = splitString.pop(); 
                  name = splitString.join('.');
    
                  // Wait! Is this a hidden file?
                  if (!name) {
                    name = '.' + extension;
                    extension = '';
                  }
                }
                // No extension
                else {
                  name = filename;
                  extension = '';
                }
    
                // Get the copy number appended to the name and increment, if any
                var matches = name.match(/\((\d+)\)$/);
                if (matches) {
                  var copyNumber = Number(matches[1]) + 1;
                  name = name.replace(/\((\d+)\)$/, '(' + copyNumber + ')'); 
                }
                else {
                  name += '(1)';
                }
    
                // Assemble new filename
                if (extension) {
                  filename = name + '.' + extension;
                }
                else {
                  filename = name;
                }
    			deferred.resolve(_getSafeFileName(filename, directory));
              }
    		  else {
              	deferred.resolve(filename);
    		  }
            }       
          });
    
        return deferred.promise;
      }
435154
function get( opts, clbk ) {
	request( opts, done );
	/**
	* FUNCTION: done( error, data )
	*	Callback invoked upon completing a request.
	*
	* @private
	* @param {Error|Null} error - error object
	* @param {String} data - response data
	* @returns {Void}
	*/
	function done( error, data ) {
		if ( error ) {
			return clbk( error );
		}
		data = transform( data );
		clbk( null, data );
	} // end FUNCTION done()
}
1152486
function get() {
      return Sizes.slideWidth * Sizes.length + Components.Gaps.grow + Components.Clones.grow;
    }
949036
def get_command(self, ctx, name):
        """"""
        if not self._commands_dir:
            return defaults.get_command(ctx, name)

        ns = {}
        fn = os.path.join(self._commands_dir, name + '.py')

        try:
            with open(fn) as f:
                code = compile(f.read(), fn, 'exec')
        except IOError:
            return defaults.get_command(ctx, name)

        eval(code, ns, ns)

        CLI = 'cli'

        try:
            return ns[CLI]
        except KeyError:
            ctx.fail('`{}` not defined in "{}"'.format(CLI, name))
761784
def with_name(self, name):
    """"""
    with self.g.as_default(), tf.variable_scope(name) as var_scope:
      name_scope = scopes.get_current_name_scope()
      return _DeferredLayer(self.bookkeeper,
                            None,
                            (),
                            {},
                            scope=(name_scope, var_scope),
                            defaults=self._defaults,
                            pass_through=self,
                            partial_context=self._partial_context)
92305
def request_get_variable(self, py_db, seq, thread_id, frame_id, scope, attrs):
        '''
        
        '''
        int_cmd = InternalGetVariable(seq, thread_id, frame_id, scope, attrs)
        py_db.post_internal_command(int_cmd, thread_id)
93595
def fetch(self):
    
    if self.id == ApiCommand.SYNCHRONOUS_COMMAND_ID:
      return self

    resp = self._get_resource_root().get(self._path())
    return ApiCommand.from_json_dict(resp, self._get_resource_root())
1299457
def get(path, options={}, raw=false, unformatted=true)
      request(:get, path, options, raw, unformatted)
    end