|coro|

        A shortcut method to :meth:`Guild.create_text_channel` to create a :class:`TextChannel` in the category.
965618
async def create_text_channel(self, name, *, overwrites=None, reason=None, **options):
        
        return await self.guild.create_text_channel(name, overwrites=overwrites, category=self, reason=reason, **options)
1359999
def create
      @category = LatoBlog::Category.new(new_category_params)

      if !@category.save
        flash[:danger] = @category.errors.full_messages.to_sentence
        redirect_to lato_blog.new_category_path
        return
      end

      flash[:success] = LANGUAGES[:lato_blog][:flashes][:category_create_success]
      redirect_to lato_blog.category_path(@category.id)
    end
571583
def create_channels_for_related_fields_in_model(model_class):
    
    need_to_create_channel = []
    for field in enum_model_fields(model_class):
        if type(field) in get_relation_field_types():
            if field.related_model == 'self':
                need_to_create_channel.append(model_class)
            elif field.related_field.model not in need_to_create_channel:
                need_to_create_channel.append(field.related_field.model)

    for field in enum_model_many_to_many(model_class):
        if type(field) in get_relation_field_types():
            if field.related_model not in need_to_create_channel:
                need_to_create_channel.append(field.related_model)

    for field_model_class in need_to_create_channel:
        if class_name_to_low_case(field_model_class.__name__) not in registry._registry:
            register_channel(field_model_class)
507954
private synchronized void createChannel(String channel) {
        if (!channelExists(channel)) {
            Queue queue = new Queue(channel, true, false, true);
            admin.declareQueue(queue);
            Binding binding = new Binding(channel, DestinationType.QUEUE, exchange.getName(), channel + ".#", null);
            admin.declareBinding(binding);
        }
    }
1022846
def copy(self):
        
        new = type(self)(str(self))
        new._init_from_channel(self)
        return new
542086
def chat_post_message(self, channel, text, **params):
        
        method = 'chat.postMessage'
        params.update({
            'channel': channel,
            'text': text,
        })
        return self._make_request(method, params)
565253
def create_widget(self):
        
        d = self.declaration
        self.widget = TextClock(self.get_context(), None, d.style)
390025
def create_task(coro, loop):
    # pragma: no cover
    """"""
    if hasattr(loop, 'create_task'):
        return loop.create_task(coro)
    return asyncio.Task(coro, loop=loop)
1325170
function createChannel(addr) {
  return amqp.connect(genAddr(addr)).then(conn => {
    return conn.createChannel().then(ch => {
      connections.push(conn);

      return [conn, ch];
    });
  }, debugError);
}
1239374
def voice_channels(self):
        """"""
        ret = [c for c in self.guild.channels
            if c.category_id == self.id
            and isinstance(c, VoiceChannel)]
        ret.sort(key=lambda c: (c.position, c.id))
        return ret
931865
async def msetup(self, text_channel):
        

        if self.mready:
            logger.warning("Attempt to init music when already initialised")
            return

        if self.state != 'starting':
            logger.error("Attempt to init from wrong state ('{}'), must be 'starting'.".format(self.state))
            return

        self.logger.debug("Setting up gui")

        # Create gui
        self.mchannel = text_channel
        self.new_embed_ui()
        await self.embed.send()
        await self.embed.usend()
        await self.add_reactions()

        self.mready = True
1351552
async def AddCharm(self, channel, url):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Client',
                   request='AddCharm',
                   version=1,
                   params=_params)
        _params['channel'] = channel
        _params['url'] = url
        reply = await self.rpc(msg)
        return reply
256293
def groups_createChild(self, *, channel: str, **kwargs) -> SlackResponse:
        
        self._validate_xoxp_token()
        kwargs.update({"channel": channel})
        return self.api_call("groups.createChild", http_verb="GET", params=kwargs)
46539
public ChannelCategory getOrCreateChannelCategory(JsonNode data) {
        long id = Long.parseLong(data.get("id").asText());
        ChannelType type = ChannelType.fromId(data.get("type").asInt());
        synchronized (this) {
            if (type == ChannelType.CHANNEL_CATEGORY) {
                return getChannelCategoryById(id).orElseGet(() -> new ChannelCategoryImpl(api, this, data));
            }
        }
        // Invalid channel type
        return null;
    }
284107
def new_category(blog_id, username, password, category_struct):
    
    authenticate(username, password, 'zinnia.add_category')
    category_dict = {'title': category_struct['name'],
                     'description': category_struct['description'],
                     'slug': category_struct['slug']}
    if int(category_struct['parent_id']):
        category_dict['parent'] = Category.objects.get(
            pk=category_struct['parent_id'])
    category = Category.objects.create(**category_dict)

    return category.pk
1228515
def create(cls, tokens:Tokens, max_vocab:int, min_freq:int) -> 'Vocab':
        ""
        freq = Counter(p for o in tokens for p in o)
        itos = [o for o,c in freq.most_common(max_vocab) if c >= min_freq]
        for o in reversed(defaults.text_spec_tok):
            if o in itos: itos.remove(o)
            itos.insert(0, o)
        return cls(itos)
163509
def construct_channel(self, **kwargs):
        
        if self.compatibility_mode:
            # Constuct channel (using function from imported chef script)
            config.LOGGER.info("Populating channel... ")
            channel = self.chef_module.construct_channel(**kwargs)
            return channel
        else:
            raise NotImplementedError('Your chef class must overrride the construct_channel method')