Das deutsche Python-Forum

Code: Alles auswählen

## info: sourceDict = self.sourceDict
## info: from concurrent.futures import ThreadPoolExecutor
## info: self.executor = ThreadPoolExecutor(max_workers=10)

futures = {self.executor.submit(self._getSource, titles, year, season, episode, imdb, provider[0], provider[1]): provider[0] for provider in sourceDict}

# der main thread laüft weiter
# weiterer code        
timeout = 30
## hier beginnt eine Schleife  mit "timeout"
for i in range(0, 4 * timeout):
    if control.abortRequested: return sys.exit()
    try:
        if progressDialog.iscanceled():
            #TODO
            self.executor.shutdown(wait=False) # nur noch nicht begonnene threads kann man so beenden
            break
    except Exception as e:
        pass
  
    # weiterer code
    # abfrage info zu allen noch nicht beendeten Threads
    
    info = [name.upper() for future, name in futures.items() if not future.done()]
    
    # weiterer code
    
    # Ende Timeout Schleife
# hier sollten alle "Threads" beendet werden die in der vorgegebenen Zeit ihre Aufgabe nicht beenden konnten

return self.sources

Code: Alles auswählen

    #futures = {self.executor.submit(self._getSource, titles, year, season, episode, imdb, provider[0], provider[1]): provider[0] for provider in sourceDict}
    threads = []
    for i in sourceDict:
        threads.append(multiprocessing.Process(target=self._getSource(titles, year, season, episode, imdb,  i[0], i[1])))
    [i.start() for i in threads]

    import pydevd
    pydevd.settrace('10.128.5.144', port=12345, stdoutToServer=True, stderrToServer=True)

    s = [i[0] + (i[1],) for i in zip(sourceDict, threads)]
    s = [(i[3].getName(), i[0], i[2]) for i in s]
    sourcelabelDict = dict([(i[0], i[1].upper()) for i in s])

Code: Alles auswählen

        futures = [
            (
                self.executor.submit(
                    self._get_source,
                    titles,
                    year,
                    season,
                    episode,
                    imdb,
                    provider_name,
                    some_value,
                ),
                provider_name,
            )
            for provider_name, some_value in source_dict
        ]

Code: Alles auswählen

            info = [
                name.upper() for future, name in futures if not future.done()
            ]

Code: Alles auswählen

        processes = [
            multiprocessing.Process(
                target=self._get_source,
                args=[titles, year, season, episode, imdb, name, some_value],
            )
            for name, some_value in source_dict
        ]
        for process in processes:
            process.start()

Code: Alles auswählen

   for i in sourceSubFolders:
        for loader, module_name, is_pkg in pkgutil.walk_packages([os.path.join(sourceFolderLocation, i)]):
            if is_pkg:
                continue
            if enabledCheck(module_name):
                try:
                    spec = importlib.util.spec_from_file_location(
                        module_name,
                        os.path.join(sourceFolderLocation, i, module_name + ".py")
                    )
                    if spec:
                        module = importlib.util.module_from_spec(spec)
                        spec.loader.exec_module(module)
                        sourceDict.append((module_name, module.source()))
                except Exception as e:
                    __addon__.setSetting('provider.' + module_name, 'false')
                    if debug:
                        log_utils.log('Error: Loading module: "%s": %s' % (module_name, e), log_utils.LOGERROR)
                    pass
    return sourceDict

Code: Alles auswählen

    def _getSource(self, titles, year, season, episode, imdb, source, call):
        try:
            sources = call.run(titles, year, season, episode, imdb)
            if sources == None or sources == []: raise Exception()
            sources = [json.loads(t) for t in set(json.dumps(d, sort_keys=True) for d in sources)]
            for i in sources:
                i.update({'provider': source})
                if not 'priority' in i: i.update({'priority': 100})
                if not 'prioHoster' in i: i.update({'prioHoster': 100})
            self.sources.extend(sources)
        except Exception as e:
            print(e)
            pass

Code: Alles auswählen

   processes = [
        multiprocessing.Process(
            target=self._getSource,
            args=[titles, year, season, episode, imdb, module_name, module_source],
        )
        for module_name, module_source in self.sourceDict
    ]
    for process in processes:
        try:
            process.start()
        except Exception as e:
            print(e)

Code: Alles auswählen

    for process in processes:
        print('process: '+ str(process))
        print('process name: '+ str(process.name))
        print('process args: '+ str(process._args))
        try:
            process.start()
        except Exception as e:
            print(e)

Code: Alles auswählen

        if spec:
            module = importlib.util.module_from_spec(spec)
            sys.modules[module_name] = module  			# Add
            spec.loader.exec_module(module)
            sourceDict.append((module_name, module.source()))

Code: Alles auswählen

    def _getSource(self, titles, year, season, episode, imdb, source, call):
        try:
            k = call.run(titles, year, season, episode, imdb)
            if k in (None, []): raise Exception()
            k = [json.loads(t) for t in set(json.dumps(d, sort_keys=True) for d in k)]
            for i in k:
                i.update({'provider': source})
                if not 'priority' in i: i.update({'priority': 100})
                if not 'prioHoster' in i: i.update({'prioHoster': 100})
            self.sources.extend(k)
        except Exception as e:
            print(e)

Code: Alles auswählen

def load_movie_information(titles, year, season, episode, imdb, provider_name, provider):
    entries = provider.run(titles, year, season, episode, imdb)
    seen = set()
    for entry in entries:
        key = json.dumps(entry, sort_keys=True)
        if key in seen:
            # duplicate entry
            continue
        seen.add(key)
        entry['provider'] = provider_name
        entry.set_default("priority", 100)
        entry.set_default("prioHoster", 100)
    return entries

Code: Alles auswählen

    sources = []
    for subfolder_name in source_subfolder_names:
        subfolder_path = source_folder_path / subfolder_name
        for module_info in pkgutil.walk_packages([str(subfolder_path)]):
            if not module_info.ispkg and enabled_check(module_info.name):
                try:
                    spec = importlib.util.spec_from_file_location(
                        module_info.name,
                        subfolder_path / f"{module_info.name}.py",
                    )
                    if spec:
                        module = importlib.util.module_from_spec(spec)
                        spec.loader.exec_module(module)
                        sources.append((module_info.name, module.source()))
                except Exception as error:
                    __addon__.setSetting(
                        f"provider.{module_info.name}", "false"
                    )
                    if debug:
                        log_utils.log(
                            f"Error: Loading module: {module_info.name!r}: {error}",
                            log_utils.LOGERROR,
                        )

    return sources

Code: Alles auswählen

def _get_sources(titles, year, season, episode, imdb, provider_name, provider):
    sources = provider.run(titles, year, season, episode, imdb)
    if sources is not None:
        for source in map(
            json.loads,
            {json.dumps(source, sort_keys=True) for source in sources},
        ):
            source["provider"] = provider_name
            source.setdefault("priority", 100)
            source.setdefault("prioHoster", 100)

    return sources

Code: Alles auswählen

from functools import partial

from more_itertools import unique_everseen

# ...

def _get_sources(titles, year, season, episode, imdb, provider_name, provider):
    sources = provider.run(titles, year, season, episode, imdb)

    if sources is not None:
        sources = list(
            unique_everseen(sources, partial(json.dumps, sort_keys=True))
        )
        for source in sources:
            source["provider"] = provider_name
            source.setdefault("priority", 100)
            source.setdefault("prioHoster", 100)

    return sources

Code: Alles auswählen

def load_movie_information(titles, year, season, episode, imdb, provider_name, provider):
    entries = provider.run(titles, year, season, episode, imdb)
    seen = set()
    for entry in entries:
        key = json.dumps(entry, sort_keys=True)
        if key not in seen:
            seen.add(key)
            entry['provider'] = provider_name
            entry.set_default("priority", 100)
            entry.set_default("prioHoster", 100)
    return entries

Code: Alles auswählen

for entry in dict.fromkeys(entries):
    ...

Code: Alles auswählen

entries = list(dict.fromkeys(entries))
for entry in entries:
    ...

Code: Alles auswählen

def load_movie_information(titles, year, season, episode, imdb, provider_name, provider):
    entries = provider.run(titles, year, season, episode, imdb)
    unique_entries = unique_everseen(entries, partial(json.dumps, sort_keys=True))
    defaults = {
        "provider": provider_name,
        "priority": 100,
        "prioHoster": 100,
    }
    return [
        defaults | entry
        for entry in unique_entries
    ]

Code: Alles auswählen

    def get_sources(self,params):
        try:
            queue = multiprocessing.SimpleQueue()
            p = multiprocessing.Process(target=self._load_movie_data, args=(queue,))
            print(p.name)
            p.start()
            queue.put("Test 1")
            sleep(1)
            return
        except Exception as e:
            print('Exception: ' + str(e))
            print()

    def _load_movie_data(self, queue):
        print(queue)

Code: Alles auswählen

    def get_sources(self,params):
        try:
            queue = multiprocessing.SimpleQueue()
            p = multiprocessing.Process(target=self._load_movie_data)
            print(p.name)
            p.start()
            queue.put("Test 1")
            return
        except Exception as e:
            print('Exception: ' + str(e))
            print()

    def _load_movie_data(self):
        print('hallo')