Create a new issue link type.
        :param outward:
        :param inward:
        :param link_type_name:
        :return:
438014
def create_issue_link_type(self, link_type_name, inward, outward):
        
        if link_type_name.lower() in [x.lower() for x in self.get_issue_link_types_names()]:
            log.error("Link type name already exists")
            return "Link type name already exists"
        data = {
            'name': link_type_name,
            'inward': inward,
            'outward': outward
        }
        return self.create_issue_link_type_by_json(data=data)
981724
def start_all_linking(self, link_type, group_id):
        """"""
        self.logger.info("start_all_linking for type %s group %s",
                         link_type, group_id)
        self.direct_command_hub('0264' + link_type + group_id)
246755
def _create_gnu_long_header(cls, name, type, encoding, errors):
        
        name = name.encode(encoding, errors) + NUL

        info = {}
        info["name"] = "././@LongLink"
        info["type"] = type
        info["size"] = len(name)
        info["magic"] = GNU_MAGIC

        # create extended header + name blocks.
        return cls._create_header(info, USTAR_FORMAT, encoding, errors) + \
                cls._create_payload(name)
1161764
def proc_forward(etype, namespace: Dict[str, Any]):
    
    return etype._eval_type(namespace, namespace) if type(etype) is _ForwardRef else etype
1025851
function Builder(mediaType, linkType) {
  this.mediaType = mediaType || mediaTypes.CONTENT_NEGOTIATION;
  this.linkType = linkType || 'link-rel';
  this.adapter = this._createAdapter(this.mediaType);
  this.autoHeaders = true;
  this.contentNegotiation = true;
  this.rawPayloadFlag = false;
  this.convertResponseToObjectFlag = false;
  this.links = [];
  this.jsonParser = JSON.parse;
  this.requestModuleInstance = standardRequest;
  this.requestOptions = {};
  this.resolveRelativeFlag = false;
  this.preferEmbedded = false;
  this.lastTraversalState = null;
  this.continuation = null;
  // Maintenance notice: when extending the list of configuration parameters,
  // also extend this.newRequest and initFromTraversalState
}
1111746
def addInternalLink(self, link):
        '''
        
        '''
        if isinstance(link, InternalLink):
            self.internalLinks.append(link)
        else:
            raise InternalLinkError( 
                'link Type should be InternalLink, not %s' % type(link))
580518
def issue(self, invoice_id, **kwargs):
        "
        url = "{}/{}/issue".format(self.base_url, invoice_id)
        return self.post_url(url, {}, **kwargs)
792994
def issue_add(lancet, assign, add_to_sprint, summary):
    
    summary = " ".join(summary)
    issue = create_issue(
        lancet,
        summary,
        # project_id=project_id,
        add_to_active_sprint=add_to_sprint,
    )
    if assign:
        if assign == "me":
            username = lancet.tracker.whoami()
        else:
            username = assign
        assign_issue(lancet, issue, username)

    click.echo("Created issue")
1178117
def get_issue_remote_links(self, issue_key, global_id=None, internal_id=None):
        
        url = 'rest/api/2/issue/{issue_key}/remotelink'.format(issue_key=issue_key)
        params = {}
        if global_id:
            params['globalId'] = global_id
        if internal_id:
            url += '/' + internal_id
        return self.get(url, params=params)
1326438
def _addPort(n: LNode, lp: LPort, intf: Interface,
             reverseDirection=False):
    
    origin = originObjOfPort(intf)
    d = intf._direction
    d = PortTypeFromDir(d)

    if reverseDirection:
        d = PortType.opposite(d)

    new_lp = LPort(lp, d, lp.side, name=intf._name)
    new_lp.originObj = origin
    if intf._interfaces:
        for child_intf in intf._interfaces:
            _addPort(n, new_lp, child_intf,
                     reverseDirection=reverseDirection)

    lp.children.append(new_lp)
    new_lp.parent = lp
    if n._node2lnode is not None:
        n._node2lnode[origin] = new_lp

    return new_lp
40089
function(name, graphType){
    Flotr.graphTypes[name] = graphType;
    Flotr.defaultOptions[name] = graphType.options || {};
    Flotr.defaultOptions.defaultType = Flotr.defaultOptions.defaultType || name;
  }
324585
def build_default_link(self):
        ''''''
        attrs = {}
        attrs["rel"] = "stylesheet"
        attrs["href"] ="{}?{:x}".format(
            os.path.join(settings.STATIC_URL, self.filepath).replace(os.path.sep, '/'),
            self.version_id,
        )
        attrs.update(self.options['link_attrs'])
        attrs["data-context"] = self.provider_run.uid       # can't be overridden
        return '<link{} />'.format(flatatt(attrs))
604679
def issuetypes(accountable, project_key):
    
    projects = accountable.issue_types(project_key)
    headers = sorted(['id', 'name', 'description'])
    rows = []
    for key, issue_types in sorted(projects.items()):
        for issue_type in issue_types:
            rows.append(
                [key] + [v for k, v in sorted(issue_type.items())
                         if k in headers]
            )
    rows.insert(0, ['project_key'] + headers)
    print_table(SingleTable(rows))
751163
def add_default(self, ext, content_type):
        
        return self._add_default(extension=ext, contentType=content_type)
678528
def issue_link_types(self):
        
        r_json = self._get_json('issueLinkType')
        link_types = [IssueLinkType(self._options, self._session, raw_link_json) for raw_link_json in
                      r_json['issueLinkTypes']]
        return link_types
145109
def link_in(self, other, preserve=False):
        
        if preserve:
            other = other.clone()
        link_modules(self, other)
70231
def link_for_image(self, base_dir: str, conf: Config) -> int:
        """"""
        return self.link_types(
            base_dir,
            [ArtifactType.app, ArtifactType.binary, ArtifactType.gen_py],
            conf)