class Tapjsonplaceholder(Tap):
    """json placeholder tap class."""

    name = "tap-jsonplaceholder"

    config_jsonschema = th.PropertiesList(
        th.Property(
            "model",
            th.StringType,
            description="Model",
        ),
        th.Property(
            "api_key",
            th.StringType,
            description="Model",
        ),
        th.Property(
            "content_type",
            th.StringType,
            description="JSON Content Type",
        ),
        th.Property(
            "base_url",
            th.StringType,
            description="Base Url",
        )
    ).to_dict()

class TableDataStream(jsonplaceholderStream):

    def __int__(
            self,
            tap: Any,
            name: str,
            model: str,
            content_type: str,
            base_url: str,
            api_key: str,
            schema: Optional[dict] = None,
        ) -> None:
            """Class initialization.

            Args:
                tap: see tap.py
                name: see tap.py
                model: see tap.py
                content_type: see tap.py
                base_url: see tap.py
                api_key: see tap.py
            """
            super().__init__(tap=tap, name=tap.name, schema=schema)
            self.name = name
            self.model = model
            self.content_type = content_type
            self.base_url = base_url
            self.api_key = api_key

    primary_keys = ["PayeeID_"]
    path = '/inputforms/0/data'
    name = "tableData"
    schema = th.PropertiesList(
        th.Property("PayeeID_", th.StringType),
        th.Property("CompPlanID", th.StringType),
        th.Property("TeamID", th.StringType),
        th.Property("Periods", th.StringType),
        th.Property("RunningTotalCredit", th.NumberType),
        th.Property("Quota", th.NumberType),
        th.Property("MonthlyAttainmentIncrease", th.NumberType),
        th.Property("StatusID", th.StringType),
        th.Property("ComponentWeighting", th.NumberType),
        th.Property("RampWeight", th.NumberType),
        th.Property("AttributeID", th.StringType),
    ).to_dict()

api_key

content_type

base_url

tap-auth0

Auth0Stream

domain

base_url

tapjsonplaceholderStream

class jsonplaceholderStream(RESTStream):
    """jsonplaceholder stream class."""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    @property
    def url_base(self) -> str:
        """Return the API URL root, configurable via tap settings."""
        # TODO: hardcode a value here, or retrieve it from self.config
        return self.config.get("base_url")

    records_jsonpath = "$[*]"  # Or override `parse_response`.

    # Set this value or override `get_new_paginator`.
    next_page_token_jsonpath = "$.next_page"  # noqa: S105

    @property
    def authenticator(self):
        return SimpleAuthenticator(
            stream=self,
            auth_headers={
                "Authorization": f"Bearer {self.config.get('api_key')}",
            },
        )

    @property
    def http_headers(self) -> dict:
        """Return the http headers needed.

        Returns:
            A dictionary of HTTP headers.
        """
        headers = {}
        headers["model"] = self.congin.get("model")
        headers["Content-Type"] = self.config.get("content_type")
        headers["Authorization"] = f"Bearer {self.config.get('api_key')}"
        if "user_agent" in self.config:
            headers["User-Agent"] = self.config.get("user_agent"),
        return headers

    def get_new_paginator(self) -> BaseAPIPaginator:
        """Create a new pagination helper instance.

        If the source API can make use of the `next_page_token_jsonpath`
        attribute, or it contains a `X-Next-Page` header in the response
        then you can remove this method.

        If you need custom pagination that uses page numbers, "next" links, or
        other approaches, please read the guide: <https://sdk.meltano.com/en/v0.25.0/guides/pagination-classes.html>.

        Returns:
            A pagination helper instance.
        """
        return super().get_new_paginator()

    def get_url_params(
        self,
        context: dict | None,  # noqa: ARG002
        next_page_token: Any | None,  # noqa: ANN401
    ) -> dict[str, Any]:
        """Return a dictionary of values to be used in URL parameterization.

        Args:
            context: The stream context.
            next_page_token: The next page index or value.

        Returns:
            A dictionary of URL query parameters.
        """
        params: dict = {}
        if next_page_token:
            params["page"] = next_page_token
        if self.replication_key:
            params["sort"] = "asc"
            params["order_by"] = self.replication_key
        return params


    def parse_response(self, response: requests.Response) -> Iterable[dict]:
        """Parse the response and return an iterator of result records.

        Args:
            response: The HTTP ``requests.Response`` object.

        Yields:
            Each record from the source.
        """
        # TODO: Parse response body and return a set of records.
        keys = [column['name'] for column in response.json()['columnDefinitions']]
        combined_data = []

        for data_row in response.json()['data']:
            if len(keys) != len(data_row):
                raise ValueError('Mismatch between keys and values length')
            combined_data.append(dict(zip(keys, data_row)))

        yield from extract_jsonpath('$[*]', input=combined_data)