Can generate a name based on the space, service name and plan.
779937
def _generate_name(self, space, service_name, plan_name):
        
        return str.join('-', [space, service_name, plan_name]).lower()
163652
def generate_project_name():
    """"""

    adjectives = [
        'aged', 'ancient', 'autumn', 'billowing', 'bitter', 'black', 'blue', 'bold',
        'broad', 'broken', 'calm', 'cold', 'cool', 'crimson', 'curly', 'damp',
        'dark', 'dawn', 'delicate', 'divine', 'dry', 'empty', 'falling', 'fancy',
        'flat', 'floral', 'fragrant', 'frosty', 'gentle', 'green', 'hidden', 'holy',
        'icy', 'jolly', 'late', 'lingering', 'little', 'lively', 'long', 'lucky',
        'misty', 'morning', 'muddy', 'mute', 'nameless', 'noisy', 'odd', 'old',
        'orange', 'patient', 'plain', 'polished', 'proud', 'purple', 'quiet', 'rapid',
        'raspy', 'red', 'restless', 'rough', 'round', 'royal', 'shiny', 'shrill',
        'shy', 'silent', 'small', 'snowy', 'soft', 'solitary', 'sparkling', 'spring',
        'square', 'steep', 'still', 'summer', 'super', 'sweet', 'throbbing', 'tight',
        'tiny', 'twilight', 'wandering', 'weathered', 'white', 'wild', 'winter', 'wispy',
        'withered', 'yellow', 'young'
    ]
    nouns = [
        'art', 'band', 'bar', 'base', 'bird', 'block', 'boat', 'bonus',
        'bread', 'breeze', 'brook', 'bush', 'butterfly', 'cake', 'cell', 'cherry',
        'cloud', 'credit', 'darkness', 'dawn', 'dew', 'disk', 'dream', 'dust',
        'feather', 'field', 'fire', 'firefly', 'flower', 'fog', 'forest', 'frog',
        'frost', 'glade', 'glitter', 'grass', 'hall', 'hat', 'haze', 'heart',
        'hill', 'king', 'lab', 'lake', 'leaf', 'limit', 'math', 'meadow',
        'mode', 'moon', 'morning', 'mountain', 'mouse', 'mud', 'night', 'paper',
        'pine', 'poetry', 'pond', 'queen', 'rain', 'recipe', 'resonance', 'rice',
        'river', 'salad', 'scene', 'sea', 'shadow', 'shape', 'silence', 'sky',
        'smoke', 'snow', 'snowflake', 'sound', 'star', 'sun', 'sun', 'sunset',
        'surf', 'term', 'thunder', 'tooth', 'tree', 'truth', 'union', 'unit',
        'violet', 'voice', 'water', 'waterfall', 'wave', 'wildflower', 'wind', 'wood'
    ]
    numbers = [str(x) for x in range(10)]
    return ' '.join([
        random.choice(adjectives).capitalize(),
        random.choice(nouns).capitalize(),
        random.choice(numbers) + random.choice(numbers),
    ])
1318163
def _msg_name(self, container, max_width):
        """"""
        name = container['name']
        if len(name) > max_width:
            name = '_' + name[-max_width + 1:]
        else:
            name = name[:max_width]
        return ' {:{width}}'.format(name, width=max_width)
348192
def generate_folder_names(self):
        """"""
        self.project_dir = os.path.join(prms.Paths.outdatadir, self.project)
        self.batch_dir = os.path.join(self.project_dir, self.name)
        self.raw_dir = os.path.join(self.batch_dir, "raw_data")
490382
def maybe_shorten_name(powerline, name):
    """"""
    max_size = powerline.segment_conf("cwd", "max_dir_size")
    if max_size:
        return name[:max_size]
    return name
1199289
function generateHoistNameBasedOn(path, suffix = "") {
  const names = [];
  if (suffix) {
    names.push(suffix);
  }

  let current = path;
  while (!(current.isIdentifier() || current.isJSXIdentifier())) {
    names.push(current.node.property.name);
    current = current.get("object");
  }
  names.push(current.node.name);

  return path.scope.generateUidIdentifier(names.reverse().join("$"));
}
1046910
private Set<String> calcPropertySourceNames(String prefix, Set<String> activeNames) {
        return ClientUtil.calcPropertySourceNames(prefix, activeNames, "_");
    }
865039
def namespace(self, key, glob=False):
        """"""
        if not self.name:
            self.name = os.environ['DJANGO_SETTINGS_MODULE'] 
        ns = '.'.join([key, self._glob]) if glob else '.'.join([self.name, self._glob])
        return ns
1269435
def create_service(self, service_type, plan_name, service_name, params,
            async=False, **kwargs):
        
        if self.space.has_service_with_name(service_name):
            logging.warning("Service already exists with that name.")
            return self.get_instance(service_name)

        if self.space.has_service_of_type(service_type):
            logging.warning("Service type already exists.")

        guid = self.get_service_plan_guid(service_type, plan_name)
        if not guid:
            raise ValueError("No service plan named: %s" % (plan_name))

        body = {
            'name': service_name,
            'space_guid': self.space.guid,
            'service_plan_guid': guid,
            'parameters': params
            }

        uri = '/v2/service_instances?accepts_incomplete=true'

        if async:
            uri += '&async=true'

        return self.api.post(uri, body)
795071
private void generateNames(Set<Property> props, Set<String> reservedNames) {
    nameGenerator.reset(reservedNames, "", reservedFirstCharacters, reservedNonFirstCharacters);
    for (Property p : props) {
      if (generatePseudoNames) {
        p.newName = "$" + p.oldName + "$";
      } else {
        // If we haven't already given this property a reusable name.
        if (p.newName == null) {
          p.newName = nameGenerator.generateNextName();
        }
      }
      reservedNames.add(p.newName);
    }
  }
1110131
def make_name(self):
        """"""
        if self.title:
            self.name = six.text_type(make_name(self.title_for_name, maxlength=self.__name_length__))
1142482
def _generate_provisional_name(q, astrom_header, fits_header):
    
    while True:
        ef = get_epoch_field(astrom_header, fits_header)
        epoch_field = ef[0] + ef[1]
        count = storage.increment_object_counter(storage.MEASURE3, epoch_field)
        try:
            q.put(ef[1] + count)
        except:
            break
438263
def _replace_spaces(self, name: str) -> str:
        
        if self.replace_spaces:
            return name.strip().replace(' ', str(self.replace_spaces_with))
        return name
93118
def stringPropertyNames(self):
        
        """
        names = set(self.data)
        if self.defaults is not None:
            names.update(self.defaults.stringPropertyNames())
        return names
8187
function getRouteNamespaces(spec) {
    let names = new Map();
    for (let id of spec.routeIDs) {
        let [namespace, explicit] = Namespace.forRoute(spec.route(id));
        namespace.log.push(`Route ${id} maps to ${namespace.fullName} (explicit = ${explicit})`);
        names.set(id, [namespace, explicit]);
    }
    return names;
}
790380
def generate(self, api):
        """"""
        for namespace in api.namespaces.values():
            # One module per namespace is created. The module takes the name
            # of the namespace.
            with self.output_to_relative_path('{}.py'.format(namespace.name)):
                self._generate_namespace_module(namespace)
776858
function (name, separator) {

                var fullName, sep = separator || "/";

                if (name.indexOf(sep) >= 0) {
                    fullName = name; //already got fully-qualified (theoretically)
                } else if (name.indexOf("Service") >= 0) {
                    fullName = "Schema" + sep + "services" + sep + name; //just got the service class name
                } else {
                    fullName = "Schema" + sep + "services" + sep + name + "Service"; //just got the service "object" name
                }

                logger.debug("Service util created full name [" + fullName + "] from [" + name + "]");

                return fullName;

            }