Consistent ordering; only works on JavaScript frontend for now

## Contributing

If creating a new scraper, just make a new class in the finder.py file, and update the example config file.

If creating a new scraper, just make a new class in the finder.py file, and update the example config file. Ensure you register it with the proper type (the `@registry.something`) line. Take a look at the other classes for all the somethings.

Scrapers should try to yield the best or near-best link first, for best compatibility with APIv4 and lower.

def get_enabled_methods():

    titles = []

    for key in config_yml["methods"]:

        method = config_yml["methods"][key]

        if method["enabled"]:

            titles.append(method["title"])

    for service in findyoutubevideo.types.registry.get_services():

        if service.enabled():

            titles.append(config_yml['methods'][service.configId]['title'])

    return titles

@app.route("/noscript_load.html")

import random, time, aiohttp, asyncio

import typing_extensions as typing

from .types import FytSession, Link, LinkContains, Service, methods, experiment_base_url

from .types import FytSession, Link, LinkContains, Service, methods, experiment_base_url, registry

from yarl import URL

async def submit_experiment(session: FytSession, experiment_name: str, video_id: str, **report):

        except Exception:

            pass

@registry.youtube

class YouTube(Service):

    """

    Checks if the video is still available on YouTube.

        )

@registry.ia

class WaybackMachine(Service):

    name = methods["ia_wayback"]["title"]

    configId = "ia_wayback"

        )

@registry.ia

class ArchiveOrgDetails(Service):

    name = methods["ia_details"]["title"]

    configId = "ia_details"

        )

@registry.ia

class ArchiveOrgCDX(Service):

    """

    Queries the Archive.org CDX for an archived video thumb

        )

@registry.misc

class GhostArchive(Service):

    name = methods["ghostarchive"]["title"]

    configId = "ghostarchive"

            metaonly=False, classname=cls.__name__

        )

@registry.on_request

class HackintYa(Service):

    name = methods["hackint_ya"]["title"]

    note = ("Video retrieval is currently not available for technical reasons. "

        )

@registry.on_request

class DistributedYoutubeArchive(Service):

    name = methods['distributed_youtube_archive']['title']

    configId = "distributed_youtube_archive"

            classname=cls.__name__

        )

@registry.public_archives

class Hobune(Service):

    name = methods["hobune_stream"]["title"]

    configId = "hobune_stream"

            note="", rawraw=raw, metaonly=False, classname=cls.__name__

        )

@registry.public_archives

class removededm(Service):

    name = methods["removededm"]["title"]

    configId = "removededm"

                    print("Login failure for removededm", j, flush = True)

                    raise RuntimeError("Login failure")

@registry.metadata

class Filmot(Service):

    name = methods["filmot"]["title"]

    lastretrieved: int = 0

                classname=cls.__name__

        )

@registry.metadata

class Playboard(Service):

    """

    Playboard is metadata-only as far as I know.

                classname=cls.__name__

        )

@registry.public_archives

class AltCensored(Service):

    """

    altCensored does not store any videos. Instead, it links to archived versions.

                rawraw=None, metaonly=False, classname=cls.__name__

        )

@registry.misc

class Odysee(Service):

    """

    Queries the LBRY YouTube Sync API to find out whether the video has been mirrored to Odysee.

            classname=cls.__name__

        )

@registry.public_archives

class PreserveTube(Service):

    name = methods["preservetube"]["title"]

    note = ""

                rawraw=None, metaonly=metaonly, classname=cls.__name__

        )

@registry.public_archives

class NyaneOnline(Service):

    name = methods['nyaneonline']['title']

    note = ""

                   rawraw=None, metaonly=False, classname=cls.__name__

        )

@registry.metadata

class LetsPlayIndex(Service):

    name = methods['letsplayindex']['title']

    note = ""

"""

import copy

import dataclasses

import enum

import time

import typing_extensions as typing

import re

    @classmethod

    def _get_services(cls) -> list[type['BaseService']]:

        serviceClasses = BaseService.__subclasses__()

        potentialServices = []

        for sc in serviceClasses:

            potentialServices.extend(sc.__subclasses__())

        services = []

        for potentialService in potentialServices:

            if not potentialService.enabled():

                continue

            services.append(potentialService)

        return services

        potentialServices = registry.get_services()

        return [service for service in potentialServices if service.enabled()]

    @classmethod

    async def new(cls, batching = False):

        return string

Response.__doc__ = Response.__doc__.replace("%s", str(Response.api_version))

class ServiceCategory(enum.Enum):

    YOUTUBE = enum.auto()

    IA = enum.auto()

    MISC = enum.auto()

    PUBLIC_ARCHIVES = enum.auto()

    ON_REQUEST = enum.auto()

    METADATA = enum.auto()

class ServiceRegistry:

    services: dict[ServiceCategory, list[Service]]

    def __init__(self):

        self.services = {k: [] for k in ServiceCategory}

    def add_service(self, category: ServiceCategory, service: Service):

        self.services[category].append(service)

    def get_services(self):

        print(self.services)

        return [j for i in self.services.values() for j in i]

    def youtube(self, service: Service):

        self.add_service(ServiceCategory.YOUTUBE, service)

    def ia(self, service: Service):

        self.add_service(ServiceCategory.IA, service)

    def misc(self, service: Service):

        self.add_service(ServiceCategory.MISC, service)

    def public_archives(self, service: Service):

        self.add_service(ServiceCategory.PUBLIC_ARCHIVES, service)

    def on_request(self, service: Service):

        self.add_service(ServiceCategory.ON_REQUEST, service)

    def metadata(self, service: Service):

        self.add_service(ServiceCategory.METADATA, service)

registry = ServiceRegistry()