Gets the LogicalDownlinks API client.

        Returns:
            LogicalDownlinks:
484996
def logical_downlinks(self):
        
        if not self.__logical_downlinks:
            self.__logical_downlinks = LogicalDownlinks(
                self.__connection)
        return self.__logical_downlinks
1166619
def get_download_url(self, proapi=False):
        
        if self._download_url is None:
            self._download_url = \
                self.api._req_files_download_url(self.pickcode, proapi)
        return self._download_url
55663
def get_link(self, path, method, callback, view):
        
        fields = self.get_path_fields(path, method, callback, view)
        fields += self.get_serializer_fields(path, method, callback, view)
        fields += self.get_pagination_fields(path, method, callback, view)
        fields += self.get_filter_fields(path, method, callback, view)

        if fields and any([field.location in ('form', 'body')
                           for field in fields]):
            encoding = self.get_encoding(path, method, callback, view)
        else:
            encoding = None

        description = self.get_description(path, method, callback, view)

        link = coreapi.Link(
            url=urlparse.urljoin(self.url, path),
            action=method.lower(),
            encoding=encoding,
            description=description,
            fields=fields,
            transform=None,  # Not handled, but here for future reference
        )
        link._responses = self.get_responses(path, method, callback, view)
        link._produces = self.get_produces(path, method, callback, view)

        return link
562970
def GetFeeds(client):
  
  feed_service = client.GetService('FeedService', 'v201809')

  feeds = []
  more_pages = True

  selector = {
      'fields': ['Id', 'Name', 'Attributes'],
      'predicates': [
          {
              'field': 'Origin',
              'operator': 'EQUALS',
              'values': ['USER']
          },
          {
              'field': 'FeedStatus',
              'operator': 'EQUALS',
              'values': ['ENABLED']
          }
      ],
      'paging': {
          'startIndex': 0,
          'numberResults': PAGE_SIZE
      }
  }

  while more_pages:
    page = feed_service.get(selector)

    if 'entries' in page:
      feeds.extend(page['entries'])

    selector['paging']['startIndex'] += PAGE_SIZE
    more_pages = selector['paging']['startIndex'] < int(page['totalNumEntries'])

  return feeds
424994
def getDownload(self, params):
        
        df = self.getData(params)
        buffer = io.StringIO()
        df.to_csv(buffer, index=False, encoding='utf-8')
        filepath = buffer
        return filepath
1020291
def getclientcustominformationurl(idclient, customfield="", *args, **kwargs):
    
    clientidparam = "/" + idclient
    url = getmambuurl(*args, **kwargs) + "clients" + clientidparam + "/custominformation" + ( ("/"+customfield) if customfield else "" )
    return url
224632
def client(self):
        
        if not hasattr(self, "_client"):
            self._client = connections.get_connection("default")
        return self._client
761367
def get_linked_deployments(deployments: Dict[str, Any]) -> Dict[str, Any]:
    
    linked_deployments = {
        dep: data
        for dep, data in deployments.items()
        if get_in(("runtime_bytecode", "link_dependencies"), data)
    }
    for deployment, data in linked_deployments.items():
        if any(
            link_dep["value"] == deployment
            for link_dep in data["runtime_bytecode"]["link_dependencies"]
        ):
            raise BytecodeLinkingError(
                f"Link dependency found in {deployment} deployment that references its "
                "own contract instance, which is disallowed"
            )
    return linked_deployments
1133949
def get_client_calls(source_code):
    # type: (str) -> APICallT
    
    parsed = parse_code(source_code)
    t = SymbolTableTypeInfer(parsed)
    binder = t.bind_types()
    collector = APICallCollector(binder)
    api_calls = collector.collect_api_calls(parsed.parsed_ast)
    return api_calls
812353
def daft_link(self):
        
        try:
            if self._data_from_search:
                link = self._data_from_search.find('a', href=True)
                return 'http://www.daft.ie' + link['href']
            else:
                return self._ad_page_content.find('link', {'rel': 'canonical'})['href']
        except Exception as e:
            if self._debug:
                logging.error(
                    "Error getting daft_link. Error message: " + e.args[0])
            return
1362892
def _get_service_bindings(self, service_name):
        
        instance = self.get_instance(service_name)
        return self.api.get(instance['service_bindings_url'])
144408
def getLinkedRequests(self):
        
        rc = api.get_tool("reference_catalog")
        refs = rc.getBackReferences(self, "AnalysisRequestAttachment")
        # fetch the objects by UID and handle nonexisting UIDs gracefully
        ars = map(lambda ref: api.get_object_by_uid(ref.sourceUID, None), refs)
        # filter out None values (nonexisting UIDs)
        ars = filter(None, ars)
        # sort by physical path, so that attachments coming from an AR with a
        # higher "-Rn" suffix get sorted correctly.
        # N.B. the created date is the same, hence we can not use it
        return sorted(ars, key=api.get_path, reverse=True)
811905
async def fetch_logical_load(self, llid):
        """"""
        url = "https://production.plum.technology/v2/getLogicalLoad"
        data = {"llid": llid}
        return await self.__post(url, data)
946744
def getClientUID(self):
        
        client = api.get_parent(self)
        if not client:
            return ""
        return api.get_uid(client)
742954
def get_api_client():
    """"""
    with _api_lock:
        global _api_client
        if not _api_client:
            conf_file = os.path.join(os.environ.get("HOME"),
                                     ".python-grid5000.yaml")
            _api_client = Client.from_yaml(conf_file)

        return _api_client
330138
def _get_links(self,):
        
        res = ''
        if self.links:
            for l in self.links:
                res += ' links = ' + str(l[0]) + '\n'
                if l[0].child_nodes:
                    for chld in l[0].child_nodes:
                        res += '   child = ' + str(chld) + '\n'
                if l[0].links:
                    for lnk in l[0].links:
                        res += '   sublink = ' + str(lnk[0]) + '\n'
        else:
            res += ' links = None\n'
            
        return res
745980
def get_logical_drives(self):
        
        logical_drives = []
        for controller in self.controllers:
            for array in controller.raid_arrays:
                for logical_drive in array.logical_drives:
                    logical_drives.append(logical_drive)
        return logical_drives