Generate a random copyright.

        :return: Copyright of company.
489777
def copyright(self) -> str:  # noqa: A003
        
        return '© {}, {}'.format(
            self.company(),
            self.company_type(abbr=True),
        )
207528
def generate_corpus(n_issuers,
                    n_tracks_per_issuer,
                    n_utts_per_track,
                    n_ll_per_utt,
                    n_label_per_ll,
                    rand=None):
    
    corpus = audiomate.Corpus()

    for issuer in generate_issuers(n_issuers, rand):
        corpus.import_issuers(issuer)

        n_tracks = rand.randint(*n_tracks_per_issuer)
        tracks = generate_tracks(n_tracks, rand)
        corpus.import_tracks(tracks)

        n_utts = rand.randint(*n_utts_per_track)
        for track in tracks:
            utts = generate_utterances(
                track,
                issuer,
                n_utts,
                n_ll_per_utt,
                n_label_per_ll,
                rand
            )

            corpus.import_utterances(utts)

    return corpus
352660
public final String getCopyright()
    {
        if ( copyright == null )
        {
            StringBuilder sb = new StringBuilder();
            sb.append( COPYRIGHT_PREAMBLE )
              .append( " " )
              .append( Calendar.getInstance().get( Calendar.YEAR ) )
              .append( " " )
              .append( companyName );
            copyright = sb.toString();
        }
        return copyright;
    }
346741
def copy(self):
        
        a = Motif()
        a.__dict__ = self.__dict__.copy()
        return a
428367
def set_copyright(self):
        """"""
        try:
            self.copyright = self.soup.find('copyright').string
        except AttributeError:
            self.copyright = None
882843
def add_copyright(
        self,
        material=None,
        holder=None,
        statement=None,
        url=None,
        year=None
    ):
        
        copyright = {}
        for key in ('holder', 'statement', 'url'):
            if locals()[key] is not None:
                copyright[key] = locals()[key]

        if material is not None:
            copyright['material'] = material.lower()

        if year is not None:
            copyright['year'] = int(year)

        self._append_to('copyright', copyright)
473274
def issn(self, mask: str = '####-####') -> str:
        
        return self.random.custom_code(mask=mask)
199420
def create_character():
    
    traits = character.CharacterCollection(character.fldr)
    c = traits.generate_random_character()
    print(c)
    return c
1284743
def randomize(self):
        
        random_pfm = [[c for c in row] for row in self.pfm]
        random.shuffle(random_pfm)
        m = Motif(pfm=random_pfm)
        m.id = "random"
        return m
1116890
def generate(self):
        '''
        
        '''
        generated_arr = np.random.uniform(
            low=0.1,
            high=0.9,
            size=((self.__batch_size, self.__seq_len, self.__dim))
        )

        if self.noise_sampler is not None:
            self.noise_sampler.output_shape = generated_arr.shape
            generated_arr += self.noise_sampler.generate()

        return generated_arr
796623
def generate_license(template, context):
    
    out = StringIO()
    content = template.getvalue()
    for key in extract_vars(template):
        if key not in context:
            raise ValueError("%s is missing from the template context" % key)
        content = content.replace("{{ %s }}" % key, context[key])
    template.close()  # free template memory (when is garbage collected?)
    out.write(content)
    return out
839573
def gen_signature(priv, pub, signature_path, auto_create=False, keysize=None):
    '''
    
    '''
    skey = get_key(__opts__)
    return skey.gen_keys_signature(priv, pub, signature_path, auto_create, keysize)
1231271
protected void generateLicenseFile() {
		final CharSequence licenseText = getLicenseText();
		if (licenseText != null) {
			final String text = licenseText.toString();
			if (!Strings.isEmpty(text)) {
				writeFile(LICENSE_FILE, text.getBytes());
			}
		}
	}
592899
def togpx(self):
        
        metadata = create_elem('metadata')
        if self.name:
            metadata.append(create_elem('name', text=self.name))
        if self.desc:
            metadata.append(create_elem('desc', text=self.desc))
        if self.author:
            element = create_elem('author')
            if self.author['name']:
                element.append(create_elem('name', text=self.author['name']))
            if self.author['email']:
                attr = dict(zip(self.author['email'].split('@'),
                                ('id', 'domain')))
                element.append(create_elem('email', attr))
            if self.author['link']:
                element.append(create_elem('link', text=self.author['link']))
            metadata.append(element)
        if self.copyright:
            if self.copyright['name']:
                author = {'author': self.copyright['name']}
            else:
                author = None
            element = create_elem('copyright', author)
            if self.copyright['year']:
                element.append(create_elem('year',
                                           text=self.copyright['year']))
            if self.copyright['license']:
                license = create_elem('license')
                element.append(license)
            metadata.append(element)
        if self.link:
            for link in self.link:
                if isinstance(link, basestring):
                    element = create_elem('link', {'href': link})
                else:
                    element = create_elem('link', {'href': link['href']})
                    if link['text']:
                        element.append(create_elem('text', text=link['text']))
                    if link['type']:
                        element.append(create_elem('type', text=link['type']))
                metadata.append(element)
        if isinstance(self.time, (time.struct_time, tuple)):
            text = time.strftime('%Y-%m-%dT%H:%M:%S%z', self.time)
        elif isinstance(self.time, utils.Timestamp):
            text = self.time.isoformat()
        else:
            text = time.strftime('%Y-%m-%dT%H:%M:%S%z')
        metadata.append(create_elem('time', text=text))
        if self.keywords:
            metadata.append(create_elem('keywords', text=self.keywords))
        if self.bounds:
            if not isinstance(self.bounds, dict):
                latitudes = list(map(attrgetter('latitude'), self.bounds))
                longitudes = list(map(attrgetter('longitude'), self.bounds))
                bounds = {
                    'minlat': str(min(latitudes)),
                    'maxlat': str(max(latitudes)),
                    'minlon': str(min(longitudes)),
                    'maxlon': str(max(longitudes)),
                }
            else:
                bounds = dict((k, str(v)) for k, v in self.bounds.items())
            metadata.append(create_elem('bounds', bounds))
        if self.extensions:
            element = create_elem('extensions')
            for i in self.extensions:
                element.append(i)
            metadata.append(self.extensions)
        return metadata
1312713
def generate_license(args):
    '''
    
    '''

    with open(cwd + licenses_loc + args[2]) as f:
        license = f.read()

    license = license.format(name=args[0],
                             email=args[1],
                             license=args[2],
                             project=args[3],
                             year=args[5])

    with open('LICENSE' + args[4], 'w') as f:
        f.write(license)
        print('licenser: license file added to current directory')
271367
def get_license(self):
        

        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.url + "/license"
        )
        return github.ContentFile.ContentFile(self._requester, headers, data, completed=True)
883531
def generate(self, step, params):
        """"""
        # Recurse into a DictFactory: allows users to have some params depending
        # on others.
        params = step.recurse(base.DictFactory, params, force_sequence=step.sequence)
        filename, content = self._make_content(params)
        return django_files.File(content.file, filename)