API Reference

Class that implements a Python Client for the JUDILIBRE API

Source code in pyjudilibre/pyjudilibre.py

class JudilibreClient:
    """Class that implements a Python Client for the **JUDILIBRE** API"""

    def __init__(
        self,
        judilibre_api_key: str | None = None,
        judilibre_api_url: str | None = None,
        judilibre_api_headers: dict = {},
        http_proxy: str | None = None,
        https_proxy: str | None = None,
        default_timeout: int = 5,
        logging_level: int = logging.ERROR,
    ):
        """Constructor of the `JudilibreClient` class

        Args:
            judilibre_api_key (str | None, optional): **JUDILIBRE** API key retrieved from [PISTE](https://piste.gouv.fr).
                If `None`, `pyjudilibre` will try to use the `JUDILIBRE_API_KEY` environment variable.
                Defaults to None.
            judilibre_api_url (_type_, optional): JUDLIBRE API URL.
                If `None`, `pyjudilibre` will try to use the `JUDILIBRE_API_URL` environment variable.
                Defaults to None.
            logging_level (int, optional): Level of logs that you want to get from `JudilibreClient`.
                Defaults to logging.INFO.
        """
        # HTTP CLIENT
        judilibre_api_url = judilibre_api_url or os.environ["JUDILIBRE_API_URL"]
        judilibre_api_key = judilibre_api_key or os.environ["JUDILIBRE_API_KEY"]

        self.judilibre_api_url = judilibre_api_url
        self.judilibre_api_key = judilibre_api_key
        self.judilibre_api_headers = judilibre_api_headers

        proxies = {
            **({"http": http_proxy} if http_proxy else {}),
            **({"https": https_proxy} if https_proxy else {}),
        }
        self.proxy_handler = urllib.request.ProxyHandler(proxies=proxies)
        self.url_opener = urllib.request.build_opener(self.proxy_handler)
        self.default_timeout = default_timeout

        self.__version__ = __version__

        self.client_headers = {
            **judilibre_api_headers,
            "KeyId": self.judilibre_api_key,
            "User-Agent": f"pyJudilibre {self.__version__}",
        }

        # LOGGING
        self._logger = logging.getLogger("judilibre-client")
        if len(self._logger.handlers) == 0:
            handler = logging.StreamHandler()
            formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
            handler.setFormatter(formatter)
            self._logger.addHandler(handler)
        self._logger.setLevel(level=logging_level)

    # @catch_wrong_url_error
    def _query(
        self,
        url: str,
        method: str = "GET",
        query_parameters: dict = {},
        timeout: int | None = None,
    ) -> dict:
        """Internal method to query the **JUDILIBRE** API constistently trhoughout methods.

        Args:
            url (str): URL endpoint to query (for example "/search", "/export")
            method (str, optional): HTTP method to use for the query.
                Defaults to "GET".
            query_parameters (dict | None, optional): query string parameters.
                Defaults to None.
            timeout (int): Number of seconds before timeout.                Defaults to 5.

        Returns:
            Response: Raw response from the JUDLIBRE API.
        """

        query_string = urllib.parse.urlencode(
            self._clean_query_parameters(query_parameters.copy()),
            doseq=True,
        )
        url = f"{self.judilibre_api_url.rstrip('/')}/{url.lstrip('/')}?{query_string}".rstrip("?")

        self._logger.info(f"REQUEST METHOD URL: {method} {url}")
        self._logger.info(f"REQUEST PARAMETERS: {query_string}")

        request = urllib.request.Request(
            method=method,
            url=url,
        )
        for key, value in self.client_headers.items():
            request.add_header(key, value)

        try:
            with self.url_opener.open(request, timeout=timeout or self.default_timeout) as response:
                content = response.read()

                self._logger.info(f"RESPONSE STATUS : {response.status}")
                self._logger.info(f"RESPONSE HEADERS: {response.headers}")
                self._logger.debug(f"RESPONSE CONTENT: {content.decode('utf-8')}")

                data = json.loads(content)

        except urllib.error.HTTPError as exc:
            if exc.status in ERROR_CODES_TO_EXCEPTIONS:
                exception = ERROR_CODES_TO_EXCEPTIONS[exc.status]
                raise exception from exc
            else:
                raise exc
        except Exception as exc:
            raise exc

        return data

    def healthcheck(
        self,
        timeout: int | None = None,
    ) -> bool:
        """Returns true if the API is up

        Returns:
            bool: True if the API is up, False else
        """
        response = self._query(
            method="GET",
            url="/healthcheck",
        )

        if response["status"] == "disponible":
            return True

        return False

    def decision(
        self,
        decision_id: str,
        *,
        timeout: int | None = None,
    ) -> JudilibreDecision:
        """Retrieves a decision from **JUDILIBRE** based on its ID

        Args:
            decision_id (str): ID of the decision on **JUDILIBRE** ("5fca9d7b5f8d5e93418f86af" for example)
            timeout (int): Number of seconds before timeout.                Defaults to 5.

        Raises:
            JudilibreDecisionNotFoundError: raised if the decision is not found on **JUDILIBRE**

        Returns:
            judilibre_decision (JudilibreDecision): a decision from **JUDILIBRE**
        """
        query_parameters = {
            "id": decision_id,
            "resolve_references": True,
        }
        try:
            response = self._query(
                method="GET",
                url="/decision",
                query_parameters=query_parameters,
                timeout=timeout or self.default_timeout,
            )
        except JudilibreResourceNotFoundError as exc:
            raise JudilibreDecisionNotFoundError(f"decision with ID {decision_id} not Found") from exc

        return JudilibreDecision(**response)

    def stats(
        self,
        *,
        keys: list[JudilibreStatsAggregationKeysEnum] | None = None,
        locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
        jurisdictions: list[JurisdictionEnum] | None = None,
        date_start: datetime.date | None = None,
        date_end: datetime.date | None = None,
        date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
        selection: bool | None = None,
        timeout: int | None = None,
    ) -> JudilibreStats:
        """Returns aggregated statistics on the decisions available in **JUDILIBRE**

        Args:
            keys (list[JudilibreStatsAggregationKeysEnum] | None, optional): list of aggregation keys to group decision numbers by.
                Defaults to None.
            locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
                If `None`, it will defaul to **JUDILIBRE** default settings.
                Defaults to None.
            jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to None.
            date_start (datetime.date | None, optional): minimal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_end (datetime.date | None, optional): maximal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_type (str | None, optional): Type of date to use for the filters.
                Defaults to "creation".
            selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
                If False, returns all the results
                Defaults to None.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.

        Returns:
            JudilibreStats: A set of statistics correponding to the given aggregation keys and filters
        """
        query_parameters = {
            **({"keys": keys} if keys is not None else {}),
            **({"date_start": date_start} if date_start is not None else {}),
            **({"date_end": date_end} if date_end is not None else {}),
            **({"date_type": date_type} if date_type else {}),
            **({"jurisdiction": jurisdictions} if jurisdictions is not None else {}),
            **({"location": locations} if locations is not None else {}),
            **({"particularInterest": "true"} if selection else {}),
        }
        response = self._query(
            method="GET",
            url="/stats",
            query_parameters=query_parameters,
            timeout=timeout or self.default_timeout,
        )
        return JudilibreStats(**response)

    def export(
        self,
        batch_number: int = 0,
        batch_size: int = 10,
        *,
        jurisdictions: list[JurisdictionEnum] | None = None,
        locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
        selection: bool | None = None,
        date_start: datetime.date | None = None,
        date_end: datetime.date | None = None,
        date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
        timeout: int | None = None,
        **kwargs,
    ) -> tuple[int, list[JudilibreDecision] | list[JudilibreShortDecision]]:
        """Returns a list of decisions based on a metadata query

        Args:
            batch_number (int, optional): Number of the batch to get.
                Defaults to 0.
            batch_size (int, optional): Size of the batch to get.
                Defaults to 10.
            jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to None.
            locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
                If `None`, it will defaul to **JUDILIBRE** default settings.
                Defaults to None.
            selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
                If False, returns all the results
                Defaults to None.
            date_start (datetime.date | None, optional): minimal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_end (datetime.date | None, optional): maximal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_type (JudilibreDateTypeEnum | None, optional): Type of date to use for the filters.
                Defaults to `None`.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.

        Returns:
            tuple[int, list[JudilibreDecision]]: a tuple containing the total number of decisions and the decisions corresponding to the current batch
        """
        query_parameters = {}

        query_parameters = {
            **({"particularInterest": "true"} if selection else {}),
            **({"location": locations} if locations else {}),
            **({"jurisdiction": jurisdictions} if jurisdictions else {}),
            **({"date_start": date_start} if date_start else {}),
            **({"date_end": date_end} if date_end else {}),
            **({"date_type": date_type} if date_type else {}),
            "resolve_references": True,
            "batch": batch_number,
            "batch_size": batch_size,
            **kwargs,
        }
        print(query_parameters)

        response = self._query(
            method="GET",
            url="/export",
            query_parameters=query_parameters,
            timeout=timeout or self.default_timeout,
        )

        if query_parameters.get("abridged") is True:
            print("ABRIDGED")
            decisions = [JudilibreShortDecision(**d) for d in response["results"]]
        else:
            print("NOT ABRIDGED", query_parameters.get("abridged"), type(query_parameters.get("abridged")))
            decisions = [JudilibreDecision(**d) for d in response["results"]]

        return (
            response["total"],
            decisions,
        )

    def search(
        self,
        query: str,
        page_size: int = 25,
        page_number: int = 0,
        *,
        operator: JudilibreOperatorEnum | None = None,
        jurisdictions: list[JurisdictionEnum] | None = None,
        locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
        selection: bool | None = None,
        date_start: datetime.date | None = None,
        date_end: datetime.date | None = None,
        date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
        timeout: int | None = None,
        **kwargs,
    ) -> tuple[int, list[JudilibreSearchResult]]:
        """Returns search results based on a plain text query

        Args:
            query (str): a plain text query
            page_size (int, optional): number of results for the page.
                Defaults to 25.
            page_number (int, optional): number of the page.
                Defaults to 0.
            operator (JudilibreOperatorEnum | None, optional): operator to use for the search.
                If `None`, it will defaul to **JUDILIBRE** default settings.
                Defaults to None.            jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to None.
            locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
                If `None`, it will defaul to **JUDILIBRE** default settings.
                Defaults to None.
            selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
                If False, returns all the results
                Defaults to None.
            date_start (datetime.date | None, optional): minimal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_end (datetime.date | None, optional): maximal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.

        Returns:
            tuple[int, list[JudilibreSearchResult]]: a tuple containing the total number of search results and the list of results corresponding to the current page
        """
        query_parameters = {
            **({"particularInterest": "true"} if selection else {}),
            **({"location": locations} if locations else {}),
            **({"date_start": date_start} if date_start else {}),
            **({"date_end": date_end} if date_end else {}),
            **({"operator": operator} if operator else {}),
            **({"jurisdiction": jurisdictions} if jurisdictions else {}),
            **({"date_type": date_type} if date_type else {}),
            **kwargs,
            "query": query,
            "page_size": page_size,
            "page": page_number,
            "resolve_references": True,
        }

        response = self._query(
            method="GET",
            url="/search",
            query_parameters=query_parameters,
            timeout=timeout or self.default_timeout,
        )

        return (
            response["total"],
            [JudilibreSearchResult(**r) for r in response["results"]],
        )

    def scan(
        self,
        batch_size: int = 100,
        *,
        jurisdictions: list[JurisdictionEnum] | None = None,
        locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
        selection: bool | None = None,
        date_start: datetime.date | None = None,
        date_end: datetime.date | None = None,
        date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
        search_after: str | None = None,
        timeout: int | None = None,
        **kwargs,
    ) -> tuple[int, list[JudilibreDecision] | list[JudilibreShortDecision], str | None]:
        """Returns a list of decisions based on a metadata query

        Args:
            search_after (str, optional): ID of the decision that will start the batch.
                Defaults to 0.
            batch_size (int, optional): Size of the batch to get.
                Defaults to 10.
            jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to None.
            locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
                If `None`, it will defaul to **JUDILIBRE** default settings.
                Defaults to None.
            selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
                If False, returns all the results
                Defaults to None.
            date_start (datetime.date | None, optional): minimal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_end (datetime.date | None, optional): maximal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_type (JudilibreDateTypeEnum | None, optional): Type of date to use for the filters.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to JudilibreDateTypeEnum.creation.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.

        Returns:
            tuple[int, list[JudilibreDecision], str | None]: a tuple containing:
                - the total number of decisions
                - the decisions corresponding to the current batch
                - the id to provide for the next batch
        """
        query_parameters = {
            **({"particularInterest": "true"} if selection else {}),
            **({"location": locations} if locations else {}),
            **({"jurisdiction": jurisdictions} if jurisdictions else {}),
            **({"date_start": date_start} if date_start else {}),
            **({"date_end": date_end} if date_end else {}),
            **({"date_type": date_type} if date_type else {}),
            **({"searchAfter": search_after} if search_after else {}),
            "resolve_references": True,
            "batch_size": batch_size,
            **kwargs,
        }

        response = self._query(
            method="GET",
            url="/scan",
            query_parameters=query_parameters,
            timeout=timeout or self.default_timeout,
        )

        total_decisions = response["total"]
        if query_parameters.get("abridged") is True:
            decisions = [JudilibreShortDecision(**d) for d in response["results"]]
        else:
            decisions = [JudilibreDecision(**d) for d in response["results"]]
        search_after = parse_qs(response["next_batch"]).get("searchAfter", [None])[0]

        return (
            total_decisions,
            decisions,
            search_after,
        )

    @staticmethod
    def _clean_query_parameters(query_parameters: dict | None) -> dict:
        if query_parameters is None:
            return {}
        if isinstance(query_parameters, dict):
            for k, v in query_parameters.items():
                query_parameters[k] = JudilibreClient._clean_query_parameters(v)
        elif isinstance(query_parameters, list):
            return [JudilibreClient._clean_query_parameters(i) for i in query_parameters]
        elif query_parameters is True:
            return "true"
        elif query_parameters is False:
            return "false"
        else:
            return JudilibreMultiValueEnum.replace_enum(query_parameters)
        return query_parameters

    def taxonomy(
        self,
        taxon_id: JudilibreTaxonEnum,
        context: JurisdictionEnum,
        *,
        taxon_key: str | None = None,
        taxon_value: str | None = None,
        timeout: int | None = None,
    ) -> dict[str, str]:
        """Returns a dictionary of key-value pairs corresponding to a taxon.
        If a `taxon_key` or a `taxon_value` is given, it will only return the dictionary for this particular key or value.

        Args:
            taxon_id (JudilibreTaxonEnum): name of the taxon to get information on
            context (JurisdictionEnum): jurisdisction type (taxons can be different for different types of jurisdictions)
            taxon_key (str | None, optional): a key of a taxon we want the value to.
                Defaults to None.
            taxon_value (str | None, optional): a value of a taxon we want the value to.
                Defaults to None.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.

        Raises:
            ValueError: if both `taxon_key` and `taxon_value` are given

        Returns:
            dict[str, str]: a dictionary of key-value pairs corresponding to a taxon
        """
        if (taxon_key is not None) and (taxon_value is not None):
            raise ValueError("At least one of taxon_key or taxon_value must be None")

        query_parameters = {
            "id": JudilibreTaxonEnum(taxon_id),
            "context_value": JurisdictionEnum(context),
            **({"key": taxon_key} if taxon_key else {}),
            **({"value": taxon_value} if taxon_value else {}),
        }

        response = self._query(
            method="GET",
            url="/taxonomy",
            query_parameters=query_parameters,
            timeout=timeout or self.default_timeout,
        )

        taxons: dict[str, str] = {}

        if taxon_key is not None:
            taxons[taxon_key] = response["result"]["value"]
        elif taxon_value is not None:
            taxons[response["result"]["key"]] = taxon_value
        else:
            taxons = response["result"]

        return taxons

    def transactional_history(
        self,
        date_start: datetime.date,
        *,
        page_size: int = 25,
        from_id: str | None = None,
        timeout: int | None = None,
    ) -> tuple[int, list[JudilibreTransaction], str | None]:
        """Returns the list of transactions after a given date

        Args:
            date_start (datetime.date): mininmal date for the transactions
            page_size (int, optional): Number of results to return at once.
                Defaults to 25.
            from_id (str | None, optional): ID of the previous query to paginate results.
                Defaults to None.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.

        Returns:
            tuple[int, list[JudilibreTransaction], str]: (
                - total number of transactions after `start_date`
                - list of transactions
                - ID of the query to paginate results
            )
        """
        query_parameters = {
            "date": date_start,
            "page_size": page_size,
            **({"from_id": from_id} if from_id else {}),
        }

        response = self._query(
            method="GET",
            url="transactionalhistory",
            query_parameters=query_parameters,
            timeout=timeout or self.default_timeout,
        )

        total_transactions = response["total"]
        next_from_id: str = parse_qs(response["next_page"]).get("from_id", [None])[0]
        transactions = [JudilibreTransaction(**t) for t in response["transactions"]]

        return (
            total_transactions,
            transactions,
            next_from_id,
        )

    def paginate_search(
        self,
        query: str,
        max_results: int | None = None,
        *,
        jurisdictions: list[JurisdictionEnum] | None = None,
        locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
        selection: bool | None = None,
        operator: JudilibreOperatorEnum | None = None,
        date_start: datetime.date | None = None,
        date_end: datetime.date | None = None,
        date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
        timeout: int | None = None,
        **kwargs,
    ) -> list[JudilibreSearchResult]:
        """Paginates through all the results from a plain text query

        Args:
            query (str): plain text string query
            max_results (int | None, optional):  maximal number of results that should be returned.
                If `None` all results are returned.
                Defaults to None.
            jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to None.
            locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
                If `None`, it will defaul to **JUDILIBRE** default settings.
                Defaults to None.
            selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
                If False, returns all the results
                Defaults to None.
            operator (JudilibreOperatorEnum | None, optional): operator to use for the search.
                If `None`, it will defaul to **JUDILIBRE** default settings.
                Defaults to None.
            date_start (datetime.date | None, optional): minimal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_end (datetime.date | None, optional): maximal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.

        Returns:
            list[JudilibreSearchResult]: list of search results corresponding to the query
        """
        page_size = 25
        page_number = 0
        next_page = True

        query_parameters = {
            **({"particularInterest": "true"} if selection else {}),
            **({"location": locations} if locations else {}),
            **({"date_start": date_start} if date_start else {}),
            **({"date_end": date_end} if date_end else {}),
            **({"operator": operator} if operator else {}),
            **({"jurisdiction": jurisdictions} if jurisdictions else {}),
            **({"date_type": date_type} if date_type else {}),
            **kwargs,
            "query": query,
            "page_size": page_size,
            "page": page_number,
            "resolve_references": True,
        }

        results = []
        n_results = 0

        while next_page:
            query_parameters["page"] = page_number

            response = self._query(
                method="GET",
                url="/search",
                query_parameters=query_parameters,
                timeout=timeout or self.default_timeout,
            )

            new_results = [JudilibreSearchResult(**r) for r in response["results"]]
            n_results += len(new_results)

            results.extend(new_results)

            if response.get("next_page") is None:
                next_page = False

            if (max_results is not None) and (n_results >= max_results):
                next_page = False

            page_number += 1

        if max_results is not None:
            return results[:max_results]
        return results

    def paginate_export(
        self,
        max_results: int | None = None,
        *,
        jurisdictions: list[JurisdictionEnum] | None = None,
        locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
        selection: bool | None = None,
        date_start: datetime.date | None = None,
        date_end: datetime.date | None = None,
        date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
        timeout: int | None = None,
        **kwargs,
    ) -> list[JudilibreDecision] | list[JudilibreShortDecision]:
        """Paginates through the results of a metadata query

        Args:
            max_results (int | None, optional):  maximal number of results that should be returned.
                If `None` all results are returned.
                Defaults to None.
            jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to None.
            locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to None.
            selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
                If False, returns all the results
                Defaults to None.
            date_start (datetime.date | None, optional): minimal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_end (datetime.date | None, optional): maximal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_type (JudilibreDateTypeEnum | None, optional): type of date to use for the date filters.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to JudilibreDateTypeEnum.creation.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.

        Returns:
            list[JudilibreDecision]: list of decisions corresponding to the query
        """
        batch_size = 100
        batch_number = 0
        next_batch = True

        query_parameters = {
            **({"particularInterest": "true"} if selection else {}),
            **({"location": locations} if locations else {}),
            **({"jurisdiction": jurisdictions} if jurisdictions else {}),
            **({"date_start": date_start} if date_start else {}),
            **({"date_end": date_end} if date_end else {}),
            **({"date_type": date_type} if date_type else {}),
            "resolve_references": True,
            "batch": batch_number,
            "batch_size": batch_size,
            **kwargs,
        }

        decisions = []
        n_decisions = 0

        while next_batch:
            query_parameters["batch"] = batch_number

            response = self._query(
                method="GET",
                url="/export",
                query_parameters=query_parameters,
                timeout=timeout or self.default_timeout,
            )

            if query_parameters.get("abridged") is True:
                new_decisions = [JudilibreShortDecision(**r) for r in response["results"]]
            else:
                new_decisions = [JudilibreDecision(**r) for r in response["results"]]
            n_decisions += len(new_decisions)

            decisions.extend(new_decisions)

            if response.get("next_batch") is None:
                next_batch = False

            if (max_results is not None) and (n_decisions >= max_results):
                next_batch = False

            batch_number += 1

        if max_results is not None:
            return decisions[:max_results]

        return decisions

    def paginate_scan(
        self,
        batch_size: int = 100,
        *,
        jurisdictions: list[JurisdictionEnum] | None = None,
        locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
        selection: bool | None = None,
        date_start: datetime.date | None = None,
        date_end: datetime.date | None = None,
        date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
        max_results: int | None = None,
        verbose: bool = False,
        timeout: int | None = None,
        **kwargs,
    ) -> list[JudilibreDecision] | list[JudilibreShortDecision]:
        """Paginates through the results of a metadata query

        Args:
            max_results (int | None, optional):  maximal number of results that should be returned.
                If `None` all results are returned.
                Defaults to None.
            jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to None.
            locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to None.
            selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
                If False, returns all the results
                Defaults to None.
            date_start (datetime.date | None, optional): minimal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_end (datetime.date | None, optional): maximal date to return results from.
                If `None` returns all the results.
                Defaults to None.
            date_type (JudilibreDateTypeEnum | None, optional): type of date to use for the date filters.
                If `None`, it will default to **JUDILIBRE** default settings.
                Defaults to JudilibreDateTypeEnum.creation.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.

        Returns:
            list[JudilibreDecision]: list of decisions corresponding to the query
        """
        decisions: list[JudilibreDecision | JudilibreShortDecision] = []
        n_decisions = 0

        progression_bar = None

        stats = self.stats(
            jurisdictions=jurisdictions,
            locations=locations,
            date_start=date_start,
            date_end=date_end,
            date_type=date_type,
            timeout=timeout or self.default_timeout,
        )

        if verbose:
            if (max_results is not None) and (stats.results.total_decisions is not None):
                progression_bar = tqdm(
                    total=min(
                        max_results,
                        stats.results.total_decisions,
                    )
                )
            else:
                progression_bar = tqdm(total=stats.results.total_decisions)

        total, decisions_tmp, search_after = self.scan(
            jurisdictions=jurisdictions,
            locations=locations,
            selection=selection,
            date_start=date_start,
            date_end=date_end,
            date_type=date_type,
            batch_size=batch_size,
            timeout=timeout or self.default_timeout,
            **kwargs,
        )

        n_decisions += len(decisions_tmp)

        if verbose and progression_bar:
            progression_bar.update(len(decisions_tmp))

        decisions.extend(decisions_tmp)

        def end_condition(
            search_after,
            max_results,
            n_decisions,
        ):
            if search_after is None:
                return True
            if max_results is None:
                return False
            if n_decisions >= max_results:
                return True

        while not end_condition(
            search_after=search_after,
            max_results=max_results,
            n_decisions=n_decisions,
        ):
            total, decisions_tmp, search_after = self.scan(
                jurisdictions=jurisdictions,
                locations=locations,
                selection=selection,
                date_start=date_start,
                date_end=date_end,
                date_type=date_type,
                search_after=search_after,
                batch_size=batch_size,
                timeout=timeout or self.default_timeout,
                **kwargs,
            )

            if verbose and progression_bar:
                progression_bar.update(len(decisions_tmp))

            n_decisions += len(decisions_tmp)
            decisions.extend(decisions_tmp)
        if max_results is not None:
            return decisions[:max_results]
        return decisions

    def paginate_transactional_history(
        self,
        date_start: datetime.datetime,
        *,
        max_results: int | None = None,
        timeout: int | None = None,
    ) -> list[JudilibreTransaction]:
        """Paginates through the transactional history results

        Args:
            date_start (datetime.datetime): minimal date to return results from.
            max_results (int | None, optional):  maximal number of results that should be returned.
                If `None` all results are returned.
                Defaults to None.
            timeout (int): Number of seconds before timeout.
                Defaults to 5.
        Returns:
            list[JudilibreTransaction]: list of transaction corresponding to the query
        """
        page_size = 500

        _, transactions, from_id = self.transactional_history(
            date_start=date_start,
            page_size=page_size,
            timeout=timeout or self.default_timeout,
        )
        n_transactions = len(transactions)

        def end_condition(
            from_id,
            max_results,
            n_transactions,
        ):
            if from_id is None:
                return True
            if max_results is None:
                return False
            if n_transactions >= max_results:
                return True

        while not end_condition(
            from_id=from_id,
            max_results=max_results,
            n_transactions=n_transactions,
        ):
            _, tmp_transactions, from_id = self.transactional_history(
                date_start=date_start,
                from_id=from_id,
                timeout=timeout or self.default_timeout,
            )
            n_transactions += len(tmp_transactions)
            transactions += tmp_transactions

        transactions = transactions[:max_results]

        return transactions

    def download_file(
        self,
        file: File,
        *,
        filename: str | None = None,
        folder: str = ".",
        timeout: int | None = None,
    ) -> str:
        """Downloads a file attached to a decision and write it on disk

        Args:
            file (File): file to download
            filename (str | None, optional): name of the file to write the content into.
                If None, uses its default name.
                Defaults to None.
            folder (str, optional): name of the folder to write the file into.
                Defaults to "." (the current folder).
            timeout (int): Number of seconds before timeout.
                Defaults to 5.
        Returns:
            str: path to downloaded file
        """

        if filename is None:
            filename = file.name

        if file.rawUrl is None:
            raise JudilibreDownloadFileError("rawUrl is not defined")

        request = urllib.request.Request(
            url=file.rawUrl,
            headers=self.client_headers,
        )

        with self.url_opener.open(
            request,
            timeout=timeout or self.default_timeout,
        ) as response:
            content: bytes = response.read()

        output_path = os.path.join(folder, filename)
        with open(output_path, "wb") as output_file:
            output_file.write(content)

        return output_path

    def download_decision_files(
        self,
        decision: JudilibreDecision,
        types: list[JudilibreFileTypeEnum] = [
            JudilibreFileTypeEnum.rapport_du_conseiller,
            JudilibreFileTypeEnum.avis_de_l_avocat_general,
        ],
        folder: str = ".",
        timeout: int | None = None,
    ) -> list[str]:
        """Download all files from a decision

        Args:
            decision (JudilibreDecision): a decision
            types (list[JudilibreFileTypeEnum], optional): a list of file types.
                Defaults to all available file types.
            folder (str, optional): folder to write files into.
                Defaults to ".".
            timeout (int): Number of seconds before timeout.
                Defaults to 5.
        Returns:
            list[str]: list of paths to downloaded files
        """
        if decision.files is None:
            return []
        files = [f for f in decision.files if f.type in types]

        filenames = []

        for f in files:
            filename = self.download_file(
                file=f,
                folder=folder,
                timeout=timeout or self.default_timeout,
            )

            filenames.append(filename)

        return filenames

__init__(judilibre_api_key=None, judilibre_api_url=None, judilibre_api_headers={}, http_proxy=None, https_proxy=None, default_timeout=5, logging_level=logging.ERROR)

Constructor of the JudilibreClient class

Parameters:

Name	Type	Description	Default
judilibre_api_key	str | None	JUDILIBRE API key retrieved from PISTE. If None, pyjudilibre will try to use the JUDILIBRE_API_KEY environment variable. Defaults to None.	None
judilibre_api_url	_type_	JUDLIBRE API URL. If None, pyjudilibre will try to use the JUDILIBRE_API_URL environment variable. Defaults to None.	None
logging_level	int	Level of logs that you want to get from JudilibreClient. Defaults to logging.INFO.	ERROR

Source code in pyjudilibre/pyjudilibre.py

def __init__(
    self,
    judilibre_api_key: str | None = None,
    judilibre_api_url: str | None = None,
    judilibre_api_headers: dict = {},
    http_proxy: str | None = None,
    https_proxy: str | None = None,
    default_timeout: int = 5,
    logging_level: int = logging.ERROR,
):
    """Constructor of the `JudilibreClient` class

    Args:
        judilibre_api_key (str | None, optional): **JUDILIBRE** API key retrieved from [PISTE](https://piste.gouv.fr).
            If `None`, `pyjudilibre` will try to use the `JUDILIBRE_API_KEY` environment variable.
            Defaults to None.
        judilibre_api_url (_type_, optional): JUDLIBRE API URL.
            If `None`, `pyjudilibre` will try to use the `JUDILIBRE_API_URL` environment variable.
            Defaults to None.
        logging_level (int, optional): Level of logs that you want to get from `JudilibreClient`.
            Defaults to logging.INFO.
    """
    # HTTP CLIENT
    judilibre_api_url = judilibre_api_url or os.environ["JUDILIBRE_API_URL"]
    judilibre_api_key = judilibre_api_key or os.environ["JUDILIBRE_API_KEY"]

    self.judilibre_api_url = judilibre_api_url
    self.judilibre_api_key = judilibre_api_key
    self.judilibre_api_headers = judilibre_api_headers

    proxies = {
        **({"http": http_proxy} if http_proxy else {}),
        **({"https": https_proxy} if https_proxy else {}),
    }
    self.proxy_handler = urllib.request.ProxyHandler(proxies=proxies)
    self.url_opener = urllib.request.build_opener(self.proxy_handler)
    self.default_timeout = default_timeout

    self.__version__ = __version__

    self.client_headers = {
        **judilibre_api_headers,
        "KeyId": self.judilibre_api_key,
        "User-Agent": f"pyJudilibre {self.__version__}",
    }

    # LOGGING
    self._logger = logging.getLogger("judilibre-client")
    if len(self._logger.handlers) == 0:
        handler = logging.StreamHandler()
        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
        handler.setFormatter(formatter)
        self._logger.addHandler(handler)
    self._logger.setLevel(level=logging_level)

healthcheck(timeout=None)

Returns true if the API is up

Returns:

Name	Type	Description
bool	bool	True if the API is up, False else

Source code in pyjudilibre/pyjudilibre.py

def healthcheck(
    self,
    timeout: int | None = None,
) -> bool:
    """Returns true if the API is up

    Returns:
        bool: True if the API is up, False else
    """
    response = self._query(
        method="GET",
        url="/healthcheck",
    )

    if response["status"] == "disponible":
        return True

    return False

decision(decision_id, *, timeout=None)

Retrieves a decision from JUDILIBRE based on its ID

Parameters:

Name	Type	Description	Default
decision_id	str	ID of the decision on JUDILIBRE ("5fca9d7b5f8d5e93418f86af" for example)	required
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Raises:

Type	Description
JudilibreDecisionNotFoundError	raised if the decision is not found on JUDILIBRE

Returns:

Name	Type	Description
judilibre_decision	JudilibreDecision	a decision from JUDILIBRE

Source code in pyjudilibre/pyjudilibre.py

def decision(
    self,
    decision_id: str,
    *,
    timeout: int | None = None,
) -> JudilibreDecision:
    """Retrieves a decision from **JUDILIBRE** based on its ID

    Args:
        decision_id (str): ID of the decision on **JUDILIBRE** ("5fca9d7b5f8d5e93418f86af" for example)
        timeout (int): Number of seconds before timeout.                Defaults to 5.

    Raises:
        JudilibreDecisionNotFoundError: raised if the decision is not found on **JUDILIBRE**

    Returns:
        judilibre_decision (JudilibreDecision): a decision from **JUDILIBRE**
    """
    query_parameters = {
        "id": decision_id,
        "resolve_references": True,
    }
    try:
        response = self._query(
            method="GET",
            url="/decision",
            query_parameters=query_parameters,
            timeout=timeout or self.default_timeout,
        )
    except JudilibreResourceNotFoundError as exc:
        raise JudilibreDecisionNotFoundError(f"decision with ID {decision_id} not Found") from exc

    return JudilibreDecision(**response)

stats(*, keys=None, locations=None, jurisdictions=None, date_start=None, date_end=None, date_type=JudilibreDateTypeEnum.creation, selection=None, timeout=None)

Returns aggregated statistics on the decisions available in JUDILIBRE

Parameters:

Name	Type	Description	Default
keys	list[JudilibreStatsAggregationKeysEnum] | None	list of aggregation keys to group decision numbers by. Defaults to None.	None
locations	list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None	list of locations (courts) to return results from. If None, it will defaul to JUDILIBRE default settings. Defaults to None.	None
jurisdictions	list[JurisdictionEnum] | None	list of jurisdictions to return results from. If None, it will default to JUDILIBRE default settings. Defaults to None.	None
date_start	date | None	minimal date to return results from. If None returns all the results. Defaults to None.	None
date_end	date | None	maximal date to return results from. If None returns all the results. Defaults to None.	None
date_type	str | None	Type of date to use for the filters. Defaults to "creation".	creation
selection	bool | None	Returns only results about decisions with a particular interest if true. If False, returns all the results Defaults to None.	None
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns:

Name	Type	Description
JudilibreStats	JudilibreStats	A set of statistics correponding to the given aggregation keys and filters

Source code in pyjudilibre/pyjudilibre.py

def stats(
    self,
    *,
    keys: list[JudilibreStatsAggregationKeysEnum] | None = None,
    locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
    jurisdictions: list[JurisdictionEnum] | None = None,
    date_start: datetime.date | None = None,
    date_end: datetime.date | None = None,
    date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
    selection: bool | None = None,
    timeout: int | None = None,
) -> JudilibreStats:
    """Returns aggregated statistics on the decisions available in **JUDILIBRE**

    Args:
        keys (list[JudilibreStatsAggregationKeysEnum] | None, optional): list of aggregation keys to group decision numbers by.
            Defaults to None.
        locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
            If `None`, it will defaul to **JUDILIBRE** default settings.
            Defaults to None.
        jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to None.
        date_start (datetime.date | None, optional): minimal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_end (datetime.date | None, optional): maximal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_type (str | None, optional): Type of date to use for the filters.
            Defaults to "creation".
        selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
            If False, returns all the results
            Defaults to None.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.

    Returns:
        JudilibreStats: A set of statistics correponding to the given aggregation keys and filters
    """
    query_parameters = {
        **({"keys": keys} if keys is not None else {}),
        **({"date_start": date_start} if date_start is not None else {}),
        **({"date_end": date_end} if date_end is not None else {}),
        **({"date_type": date_type} if date_type else {}),
        **({"jurisdiction": jurisdictions} if jurisdictions is not None else {}),
        **({"location": locations} if locations is not None else {}),
        **({"particularInterest": "true"} if selection else {}),
    }
    response = self._query(
        method="GET",
        url="/stats",
        query_parameters=query_parameters,
        timeout=timeout or self.default_timeout,
    )
    return JudilibreStats(**response)

export(batch_number=0, batch_size=10, *, jurisdictions=None, locations=None, selection=None, date_start=None, date_end=None, date_type=JudilibreDateTypeEnum.creation, timeout=None, **kwargs)

Returns a list of decisions based on a metadata query

Parameters:

Name	Type	Description	Default
batch_number	int	Number of the batch to get. Defaults to 0.	0
batch_size	int	Size of the batch to get. Defaults to 10.	10
jurisdictions	list[JurisdictionEnum] | None	list of jurisdictions to return results from. If None, it will default to JUDILIBRE default settings. Defaults to None.	None
locations	list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None	list of locations (courts) to return results from. If None, it will defaul to JUDILIBRE default settings. Defaults to None.	None
selection	bool | None	Returns only results about decisions with a particular interest if true. If False, returns all the results Defaults to None.	None
date_start	date | None	minimal date to return results from. If None returns all the results. Defaults to None.	None
date_end	date | None	maximal date to return results from. If None returns all the results. Defaults to None.	None
date_type	JudilibreDateTypeEnum | None	Type of date to use for the filters. Defaults to None.	creation
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns:

Type	Description
tuple[int, list[JudilibreDecision] | list[JudilibreShortDecision]]	tuple[int, list[JudilibreDecision]]: a tuple containing the total number of decisions and the decisions corresponding to the current batch

Source code in pyjudilibre/pyjudilibre.py

def export(
    self,
    batch_number: int = 0,
    batch_size: int = 10,
    *,
    jurisdictions: list[JurisdictionEnum] | None = None,
    locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
    selection: bool | None = None,
    date_start: datetime.date | None = None,
    date_end: datetime.date | None = None,
    date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
    timeout: int | None = None,
    **kwargs,
) -> tuple[int, list[JudilibreDecision] | list[JudilibreShortDecision]]:
    """Returns a list of decisions based on a metadata query

    Args:
        batch_number (int, optional): Number of the batch to get.
            Defaults to 0.
        batch_size (int, optional): Size of the batch to get.
            Defaults to 10.
        jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to None.
        locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
            If `None`, it will defaul to **JUDILIBRE** default settings.
            Defaults to None.
        selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
            If False, returns all the results
            Defaults to None.
        date_start (datetime.date | None, optional): minimal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_end (datetime.date | None, optional): maximal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_type (JudilibreDateTypeEnum | None, optional): Type of date to use for the filters.
            Defaults to `None`.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.

    Returns:
        tuple[int, list[JudilibreDecision]]: a tuple containing the total number of decisions and the decisions corresponding to the current batch
    """
    query_parameters = {}

    query_parameters = {
        **({"particularInterest": "true"} if selection else {}),
        **({"location": locations} if locations else {}),
        **({"jurisdiction": jurisdictions} if jurisdictions else {}),
        **({"date_start": date_start} if date_start else {}),
        **({"date_end": date_end} if date_end else {}),
        **({"date_type": date_type} if date_type else {}),
        "resolve_references": True,
        "batch": batch_number,
        "batch_size": batch_size,
        **kwargs,
    }
    print(query_parameters)

    response = self._query(
        method="GET",
        url="/export",
        query_parameters=query_parameters,
        timeout=timeout or self.default_timeout,
    )

    if query_parameters.get("abridged") is True:
        print("ABRIDGED")
        decisions = [JudilibreShortDecision(**d) for d in response["results"]]
    else:
        print("NOT ABRIDGED", query_parameters.get("abridged"), type(query_parameters.get("abridged")))
        decisions = [JudilibreDecision(**d) for d in response["results"]]

    return (
        response["total"],
        decisions,
    )

search(query, page_size=25, page_number=0, *, operator=None, jurisdictions=None, locations=None, selection=None, date_start=None, date_end=None, date_type=JudilibreDateTypeEnum.creation, timeout=None, **kwargs)

Returns search results based on a plain text query

Parameters:

Name	Type	Description	Default
query	str	a plain text query	required
page_size	int	number of results for the page. Defaults to 25.	25
page_number	int	number of the page. Defaults to 0.	0
operator	JudilibreOperatorEnum | None	operator to use for the search. If None, it will defaul to JUDILIBRE default settings. Defaults to None. jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from. If None, it will default to JUDILIBRE default settings. Defaults to None.	None
locations	list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None	list of locations (courts) to return results from. If None, it will defaul to JUDILIBRE default settings. Defaults to None.	None
selection	bool | None	Returns only results about decisions with a particular interest if true. If False, returns all the results Defaults to None.	None
date_start	date | None	minimal date to return results from. If None returns all the results. Defaults to None.	None
date_end	date | None	maximal date to return results from. If None returns all the results. Defaults to None.	None
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns:

Type	Description
tuple[int, list[JudilibreSearchResult]]	tuple[int, list[JudilibreSearchResult]]: a tuple containing the total number of search results and the list of results corresponding to the current page

Source code in pyjudilibre/pyjudilibre.py

def search(
    self,
    query: str,
    page_size: int = 25,
    page_number: int = 0,
    *,
    operator: JudilibreOperatorEnum | None = None,
    jurisdictions: list[JurisdictionEnum] | None = None,
    locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
    selection: bool | None = None,
    date_start: datetime.date | None = None,
    date_end: datetime.date | None = None,
    date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
    timeout: int | None = None,
    **kwargs,
) -> tuple[int, list[JudilibreSearchResult]]:
    """Returns search results based on a plain text query

    Args:
        query (str): a plain text query
        page_size (int, optional): number of results for the page.
            Defaults to 25.
        page_number (int, optional): number of the page.
            Defaults to 0.
        operator (JudilibreOperatorEnum | None, optional): operator to use for the search.
            If `None`, it will defaul to **JUDILIBRE** default settings.
            Defaults to None.            jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to None.
        locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
            If `None`, it will defaul to **JUDILIBRE** default settings.
            Defaults to None.
        selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
            If False, returns all the results
            Defaults to None.
        date_start (datetime.date | None, optional): minimal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_end (datetime.date | None, optional): maximal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.

    Returns:
        tuple[int, list[JudilibreSearchResult]]: a tuple containing the total number of search results and the list of results corresponding to the current page
    """
    query_parameters = {
        **({"particularInterest": "true"} if selection else {}),
        **({"location": locations} if locations else {}),
        **({"date_start": date_start} if date_start else {}),
        **({"date_end": date_end} if date_end else {}),
        **({"operator": operator} if operator else {}),
        **({"jurisdiction": jurisdictions} if jurisdictions else {}),
        **({"date_type": date_type} if date_type else {}),
        **kwargs,
        "query": query,
        "page_size": page_size,
        "page": page_number,
        "resolve_references": True,
    }

    response = self._query(
        method="GET",
        url="/search",
        query_parameters=query_parameters,
        timeout=timeout or self.default_timeout,
    )

    return (
        response["total"],
        [JudilibreSearchResult(**r) for r in response["results"]],
    )

scan(batch_size=100, *, jurisdictions=None, locations=None, selection=None, date_start=None, date_end=None, date_type=JudilibreDateTypeEnum.creation, search_after=None, timeout=None, **kwargs)

Returns a list of decisions based on a metadata query

Parameters:

Name	Type	Description	Default
search_after	str	ID of the decision that will start the batch. Defaults to 0.	None
batch_size	int	Size of the batch to get. Defaults to 10.	100
jurisdictions	list[JurisdictionEnum] | None	list of jurisdictions to return results from. If None, it will default to JUDILIBRE default settings. Defaults to None.	None
locations	list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None	list of locations (courts) to return results from. If None, it will defaul to JUDILIBRE default settings. Defaults to None.	None
selection	bool | None	Returns only results about decisions with a particular interest if true. If False, returns all the results Defaults to None.	None
date_start	date | None	minimal date to return results from. If None returns all the results. Defaults to None.	None
date_end	date | None	maximal date to return results from. If None returns all the results. Defaults to None.	None
date_type	JudilibreDateTypeEnum | None	Type of date to use for the filters. If None, it will default to JUDILIBRE default settings. Defaults to JudilibreDateTypeEnum.creation.	creation
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns:

Type	Description
tuple[int, list[JudilibreDecision] | list[JudilibreShortDecision], str | None]	tuple[int, list[JudilibreDecision], str | None]: a tuple containing: - the total number of decisions - the decisions corresponding to the current batch - the id to provide for the next batch

Source code in pyjudilibre/pyjudilibre.py

def scan(
    self,
    batch_size: int = 100,
    *,
    jurisdictions: list[JurisdictionEnum] | None = None,
    locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
    selection: bool | None = None,
    date_start: datetime.date | None = None,
    date_end: datetime.date | None = None,
    date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
    search_after: str | None = None,
    timeout: int | None = None,
    **kwargs,
) -> tuple[int, list[JudilibreDecision] | list[JudilibreShortDecision], str | None]:
    """Returns a list of decisions based on a metadata query

    Args:
        search_after (str, optional): ID of the decision that will start the batch.
            Defaults to 0.
        batch_size (int, optional): Size of the batch to get.
            Defaults to 10.
        jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to None.
        locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
            If `None`, it will defaul to **JUDILIBRE** default settings.
            Defaults to None.
        selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
            If False, returns all the results
            Defaults to None.
        date_start (datetime.date | None, optional): minimal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_end (datetime.date | None, optional): maximal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_type (JudilibreDateTypeEnum | None, optional): Type of date to use for the filters.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to JudilibreDateTypeEnum.creation.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.

    Returns:
        tuple[int, list[JudilibreDecision], str | None]: a tuple containing:
            - the total number of decisions
            - the decisions corresponding to the current batch
            - the id to provide for the next batch
    """
    query_parameters = {
        **({"particularInterest": "true"} if selection else {}),
        **({"location": locations} if locations else {}),
        **({"jurisdiction": jurisdictions} if jurisdictions else {}),
        **({"date_start": date_start} if date_start else {}),
        **({"date_end": date_end} if date_end else {}),
        **({"date_type": date_type} if date_type else {}),
        **({"searchAfter": search_after} if search_after else {}),
        "resolve_references": True,
        "batch_size": batch_size,
        **kwargs,
    }

    response = self._query(
        method="GET",
        url="/scan",
        query_parameters=query_parameters,
        timeout=timeout or self.default_timeout,
    )

    total_decisions = response["total"]
    if query_parameters.get("abridged") is True:
        decisions = [JudilibreShortDecision(**d) for d in response["results"]]
    else:
        decisions = [JudilibreDecision(**d) for d in response["results"]]
    search_after = parse_qs(response["next_batch"]).get("searchAfter", [None])[0]

    return (
        total_decisions,
        decisions,
        search_after,
    )

taxonomy(taxon_id, context, *, taxon_key=None, taxon_value=None, timeout=None)

Returns a dictionary of key-value pairs corresponding to a taxon. If a taxon_key or a taxon_value is given, it will only return the dictionary for this particular key or value.

Parameters:

Name	Type	Description	Default
taxon_id	JudilibreTaxonEnum	name of the taxon to get information on	required
context	JurisdictionEnum	jurisdisction type (taxons can be different for different types of jurisdictions)	required
taxon_key	str | None	a key of a taxon we want the value to. Defaults to None.	None
taxon_value	str | None	a value of a taxon we want the value to. Defaults to None.	None
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Raises:

Type	Description
ValueError	if both taxon_key and taxon_value are given

Returns:

Type	Description
dict[str, str]	dict[str, str]: a dictionary of key-value pairs corresponding to a taxon

Source code in pyjudilibre/pyjudilibre.py

def taxonomy(
    self,
    taxon_id: JudilibreTaxonEnum,
    context: JurisdictionEnum,
    *,
    taxon_key: str | None = None,
    taxon_value: str | None = None,
    timeout: int | None = None,
) -> dict[str, str]:
    """Returns a dictionary of key-value pairs corresponding to a taxon.
    If a `taxon_key` or a `taxon_value` is given, it will only return the dictionary for this particular key or value.

    Args:
        taxon_id (JudilibreTaxonEnum): name of the taxon to get information on
        context (JurisdictionEnum): jurisdisction type (taxons can be different for different types of jurisdictions)
        taxon_key (str | None, optional): a key of a taxon we want the value to.
            Defaults to None.
        taxon_value (str | None, optional): a value of a taxon we want the value to.
            Defaults to None.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.

    Raises:
        ValueError: if both `taxon_key` and `taxon_value` are given

    Returns:
        dict[str, str]: a dictionary of key-value pairs corresponding to a taxon
    """
    if (taxon_key is not None) and (taxon_value is not None):
        raise ValueError("At least one of taxon_key or taxon_value must be None")

    query_parameters = {
        "id": JudilibreTaxonEnum(taxon_id),
        "context_value": JurisdictionEnum(context),
        **({"key": taxon_key} if taxon_key else {}),
        **({"value": taxon_value} if taxon_value else {}),
    }

    response = self._query(
        method="GET",
        url="/taxonomy",
        query_parameters=query_parameters,
        timeout=timeout or self.default_timeout,
    )

    taxons: dict[str, str] = {}

    if taxon_key is not None:
        taxons[taxon_key] = response["result"]["value"]
    elif taxon_value is not None:
        taxons[response["result"]["key"]] = taxon_value
    else:
        taxons = response["result"]

    return taxons

transactional_history(date_start, *, page_size=25, from_id=None, timeout=None)

Returns the list of transactions after a given date

Parameters:

Name	Type	Description	Default
date_start	date	mininmal date for the transactions	required
page_size	int	Number of results to return at once. Defaults to 25.	25
from_id	str | None	ID of the previous query to paginate results. Defaults to None.	None
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns:

Type	Description
int	tuple[int, list[JudilibreTransaction], str]: ( - total number of transactions after start_date - list of transactions - ID of the query to paginate results
list[JudilibreTransaction]	)

Source code in pyjudilibre/pyjudilibre.py

def transactional_history(
    self,
    date_start: datetime.date,
    *,
    page_size: int = 25,
    from_id: str | None = None,
    timeout: int | None = None,
) -> tuple[int, list[JudilibreTransaction], str | None]:
    """Returns the list of transactions after a given date

    Args:
        date_start (datetime.date): mininmal date for the transactions
        page_size (int, optional): Number of results to return at once.
            Defaults to 25.
        from_id (str | None, optional): ID of the previous query to paginate results.
            Defaults to None.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.

    Returns:
        tuple[int, list[JudilibreTransaction], str]: (
            - total number of transactions after `start_date`
            - list of transactions
            - ID of the query to paginate results
        )
    """
    query_parameters = {
        "date": date_start,
        "page_size": page_size,
        **({"from_id": from_id} if from_id else {}),
    }

    response = self._query(
        method="GET",
        url="transactionalhistory",
        query_parameters=query_parameters,
        timeout=timeout or self.default_timeout,
    )

    total_transactions = response["total"]
    next_from_id: str = parse_qs(response["next_page"]).get("from_id", [None])[0]
    transactions = [JudilibreTransaction(**t) for t in response["transactions"]]

    return (
        total_transactions,
        transactions,
        next_from_id,
    )

paginate_search(query, max_results=None, *, jurisdictions=None, locations=None, selection=None, operator=None, date_start=None, date_end=None, date_type=JudilibreDateTypeEnum.creation, timeout=None, **kwargs)

Paginates through all the results from a plain text query

Parameters:

Name	Type	Description	Default
query	str	plain text string query	required
max_results	int | None	maximal number of results that should be returned. If None all results are returned. Defaults to None.	None
jurisdictions	list[JurisdictionEnum] | None	list of jurisdictions to return results from. If None, it will default to JUDILIBRE default settings. Defaults to None.	None
locations	list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None	list of locations (courts) to return results from. If None, it will defaul to JUDILIBRE default settings. Defaults to None.	None
selection	bool | None	Returns only results about decisions with a particular interest if true. If False, returns all the results Defaults to None.	None
operator	JudilibreOperatorEnum | None	operator to use for the search. If None, it will defaul to JUDILIBRE default settings. Defaults to None.	None
date_start	date | None	minimal date to return results from. If None returns all the results. Defaults to None.	None
date_end	date | None	maximal date to return results from. If None returns all the results. Defaults to None.	None
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns:

Type	Description
list[JudilibreSearchResult]	list[JudilibreSearchResult]: list of search results corresponding to the query

Source code in pyjudilibre/pyjudilibre.py

def paginate_search(
    self,
    query: str,
    max_results: int | None = None,
    *,
    jurisdictions: list[JurisdictionEnum] | None = None,
    locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
    selection: bool | None = None,
    operator: JudilibreOperatorEnum | None = None,
    date_start: datetime.date | None = None,
    date_end: datetime.date | None = None,
    date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
    timeout: int | None = None,
    **kwargs,
) -> list[JudilibreSearchResult]:
    """Paginates through all the results from a plain text query

    Args:
        query (str): plain text string query
        max_results (int | None, optional):  maximal number of results that should be returned.
            If `None` all results are returned.
            Defaults to None.
        jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to None.
        locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
            If `None`, it will defaul to **JUDILIBRE** default settings.
            Defaults to None.
        selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
            If False, returns all the results
            Defaults to None.
        operator (JudilibreOperatorEnum | None, optional): operator to use for the search.
            If `None`, it will defaul to **JUDILIBRE** default settings.
            Defaults to None.
        date_start (datetime.date | None, optional): minimal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_end (datetime.date | None, optional): maximal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.

    Returns:
        list[JudilibreSearchResult]: list of search results corresponding to the query
    """
    page_size = 25
    page_number = 0
    next_page = True

    query_parameters = {
        **({"particularInterest": "true"} if selection else {}),
        **({"location": locations} if locations else {}),
        **({"date_start": date_start} if date_start else {}),
        **({"date_end": date_end} if date_end else {}),
        **({"operator": operator} if operator else {}),
        **({"jurisdiction": jurisdictions} if jurisdictions else {}),
        **({"date_type": date_type} if date_type else {}),
        **kwargs,
        "query": query,
        "page_size": page_size,
        "page": page_number,
        "resolve_references": True,
    }

    results = []
    n_results = 0

    while next_page:
        query_parameters["page"] = page_number

        response = self._query(
            method="GET",
            url="/search",
            query_parameters=query_parameters,
            timeout=timeout or self.default_timeout,
        )

        new_results = [JudilibreSearchResult(**r) for r in response["results"]]
        n_results += len(new_results)

        results.extend(new_results)

        if response.get("next_page") is None:
            next_page = False

        if (max_results is not None) and (n_results >= max_results):
            next_page = False

        page_number += 1

    if max_results is not None:
        return results[:max_results]
    return results

paginate_export(max_results=None, *, jurisdictions=None, locations=None, selection=None, date_start=None, date_end=None, date_type=JudilibreDateTypeEnum.creation, timeout=None, **kwargs)

Paginates through the results of a metadata query

Parameters:

Name	Type	Description	Default
max_results	int | None	maximal number of results that should be returned. If None all results are returned. Defaults to None.	None
jurisdictions	list[JurisdictionEnum] | None	list of jurisdictions to return results from. If None, it will default to JUDILIBRE default settings. Defaults to None.	None
locations	list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None	list of locations (courts) to return results from. If None, it will default to JUDILIBRE default settings. Defaults to None.	None
selection	bool | None	Returns only results about decisions with a particular interest if true. If False, returns all the results Defaults to None.	None
date_start	date | None	minimal date to return results from. If None returns all the results. Defaults to None.	None
date_end	date | None	maximal date to return results from. If None returns all the results. Defaults to None.	None
date_type	JudilibreDateTypeEnum | None	type of date to use for the date filters. If None, it will default to JUDILIBRE default settings. Defaults to JudilibreDateTypeEnum.creation.	creation
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns:

Type	Description
list[JudilibreDecision] | list[JudilibreShortDecision]	list[JudilibreDecision]: list of decisions corresponding to the query

Source code in pyjudilibre/pyjudilibre.py

def paginate_export(
    self,
    max_results: int | None = None,
    *,
    jurisdictions: list[JurisdictionEnum] | None = None,
    locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
    selection: bool | None = None,
    date_start: datetime.date | None = None,
    date_end: datetime.date | None = None,
    date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
    timeout: int | None = None,
    **kwargs,
) -> list[JudilibreDecision] | list[JudilibreShortDecision]:
    """Paginates through the results of a metadata query

    Args:
        max_results (int | None, optional):  maximal number of results that should be returned.
            If `None` all results are returned.
            Defaults to None.
        jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to None.
        locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to None.
        selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
            If False, returns all the results
            Defaults to None.
        date_start (datetime.date | None, optional): minimal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_end (datetime.date | None, optional): maximal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_type (JudilibreDateTypeEnum | None, optional): type of date to use for the date filters.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to JudilibreDateTypeEnum.creation.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.

    Returns:
        list[JudilibreDecision]: list of decisions corresponding to the query
    """
    batch_size = 100
    batch_number = 0
    next_batch = True

    query_parameters = {
        **({"particularInterest": "true"} if selection else {}),
        **({"location": locations} if locations else {}),
        **({"jurisdiction": jurisdictions} if jurisdictions else {}),
        **({"date_start": date_start} if date_start else {}),
        **({"date_end": date_end} if date_end else {}),
        **({"date_type": date_type} if date_type else {}),
        "resolve_references": True,
        "batch": batch_number,
        "batch_size": batch_size,
        **kwargs,
    }

    decisions = []
    n_decisions = 0

    while next_batch:
        query_parameters["batch"] = batch_number

        response = self._query(
            method="GET",
            url="/export",
            query_parameters=query_parameters,
            timeout=timeout or self.default_timeout,
        )

        if query_parameters.get("abridged") is True:
            new_decisions = [JudilibreShortDecision(**r) for r in response["results"]]
        else:
            new_decisions = [JudilibreDecision(**r) for r in response["results"]]
        n_decisions += len(new_decisions)

        decisions.extend(new_decisions)

        if response.get("next_batch") is None:
            next_batch = False

        if (max_results is not None) and (n_decisions >= max_results):
            next_batch = False

        batch_number += 1

    if max_results is not None:
        return decisions[:max_results]

    return decisions

paginate_scan(batch_size=100, *, jurisdictions=None, locations=None, selection=None, date_start=None, date_end=None, date_type=JudilibreDateTypeEnum.creation, max_results=None, verbose=False, timeout=None, **kwargs)

Paginates through the results of a metadata query

Parameters:

Name	Type	Description	Default
max_results	int | None	maximal number of results that should be returned. If None all results are returned. Defaults to None.	None
jurisdictions	list[JurisdictionEnum] | None	list of jurisdictions to return results from. If None, it will default to JUDILIBRE default settings. Defaults to None.	None
locations	list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None	list of locations (courts) to return results from. If None, it will default to JUDILIBRE default settings. Defaults to None.	None
selection	bool | None	Returns only results about decisions with a particular interest if true. If False, returns all the results Defaults to None.	None
date_start	date | None	minimal date to return results from. If None returns all the results. Defaults to None.	None
date_end	date | None	maximal date to return results from. If None returns all the results. Defaults to None.	None
date_type	JudilibreDateTypeEnum | None	type of date to use for the date filters. If None, it will default to JUDILIBRE default settings. Defaults to JudilibreDateTypeEnum.creation.	creation
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns:

Type	Description
list[JudilibreDecision] | list[JudilibreShortDecision]	list[JudilibreDecision]: list of decisions corresponding to the query

Source code in pyjudilibre/pyjudilibre.py

def paginate_scan(
    self,
    batch_size: int = 100,
    *,
    jurisdictions: list[JurisdictionEnum] | None = None,
    locations: list[LocationCAEnum | LocationTJEnum | LocationTCOMEnum] | None = None,
    selection: bool | None = None,
    date_start: datetime.date | None = None,
    date_end: datetime.date | None = None,
    date_type: JudilibreDateTypeEnum | None = JudilibreDateTypeEnum.creation,
    max_results: int | None = None,
    verbose: bool = False,
    timeout: int | None = None,
    **kwargs,
) -> list[JudilibreDecision] | list[JudilibreShortDecision]:
    """Paginates through the results of a metadata query

    Args:
        max_results (int | None, optional):  maximal number of results that should be returned.
            If `None` all results are returned.
            Defaults to None.
        jurisdictions (list[JurisdictionEnum] | None, optional): list of jurisdictions to return results from.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to None.
        locations (list[LocationCAEnum  |  LocationTJEnum  |  LocationTCOMEnum] | None, optional): list of locations (courts) to return results from.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to None.
        selection (bool | None, optional): Returns only results about decisions with a particular interest if true.
            If False, returns all the results
            Defaults to None.
        date_start (datetime.date | None, optional): minimal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_end (datetime.date | None, optional): maximal date to return results from.
            If `None` returns all the results.
            Defaults to None.
        date_type (JudilibreDateTypeEnum | None, optional): type of date to use for the date filters.
            If `None`, it will default to **JUDILIBRE** default settings.
            Defaults to JudilibreDateTypeEnum.creation.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.

    Returns:
        list[JudilibreDecision]: list of decisions corresponding to the query
    """
    decisions: list[JudilibreDecision | JudilibreShortDecision] = []
    n_decisions = 0

    progression_bar = None

    stats = self.stats(
        jurisdictions=jurisdictions,
        locations=locations,
        date_start=date_start,
        date_end=date_end,
        date_type=date_type,
        timeout=timeout or self.default_timeout,
    )

    if verbose:
        if (max_results is not None) and (stats.results.total_decisions is not None):
            progression_bar = tqdm(
                total=min(
                    max_results,
                    stats.results.total_decisions,
                )
            )
        else:
            progression_bar = tqdm(total=stats.results.total_decisions)

    total, decisions_tmp, search_after = self.scan(
        jurisdictions=jurisdictions,
        locations=locations,
        selection=selection,
        date_start=date_start,
        date_end=date_end,
        date_type=date_type,
        batch_size=batch_size,
        timeout=timeout or self.default_timeout,
        **kwargs,
    )

    n_decisions += len(decisions_tmp)

    if verbose and progression_bar:
        progression_bar.update(len(decisions_tmp))

    decisions.extend(decisions_tmp)

    def end_condition(
        search_after,
        max_results,
        n_decisions,
    ):
        if search_after is None:
            return True
        if max_results is None:
            return False
        if n_decisions >= max_results:
            return True

    while not end_condition(
        search_after=search_after,
        max_results=max_results,
        n_decisions=n_decisions,
    ):
        total, decisions_tmp, search_after = self.scan(
            jurisdictions=jurisdictions,
            locations=locations,
            selection=selection,
            date_start=date_start,
            date_end=date_end,
            date_type=date_type,
            search_after=search_after,
            batch_size=batch_size,
            timeout=timeout or self.default_timeout,
            **kwargs,
        )

        if verbose and progression_bar:
            progression_bar.update(len(decisions_tmp))

        n_decisions += len(decisions_tmp)
        decisions.extend(decisions_tmp)
    if max_results is not None:
        return decisions[:max_results]
    return decisions

paginate_transactional_history(date_start, *, max_results=None, timeout=None)

Paginates through the transactional history results

Parameters:

Name	Type	Description	Default
date_start	datetime	minimal date to return results from.	required
max_results	int | None	maximal number of results that should be returned. If None all results are returned. Defaults to None.	None
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns: list[JudilibreTransaction]: list of transaction corresponding to the query

Source code in pyjudilibre/pyjudilibre.py

def paginate_transactional_history(
    self,
    date_start: datetime.datetime,
    *,
    max_results: int | None = None,
    timeout: int | None = None,
) -> list[JudilibreTransaction]:
    """Paginates through the transactional history results

    Args:
        date_start (datetime.datetime): minimal date to return results from.
        max_results (int | None, optional):  maximal number of results that should be returned.
            If `None` all results are returned.
            Defaults to None.
        timeout (int): Number of seconds before timeout.
            Defaults to 5.
    Returns:
        list[JudilibreTransaction]: list of transaction corresponding to the query
    """
    page_size = 500

    _, transactions, from_id = self.transactional_history(
        date_start=date_start,
        page_size=page_size,
        timeout=timeout or self.default_timeout,
    )
    n_transactions = len(transactions)

    def end_condition(
        from_id,
        max_results,
        n_transactions,
    ):
        if from_id is None:
            return True
        if max_results is None:
            return False
        if n_transactions >= max_results:
            return True

    while not end_condition(
        from_id=from_id,
        max_results=max_results,
        n_transactions=n_transactions,
    ):
        _, tmp_transactions, from_id = self.transactional_history(
            date_start=date_start,
            from_id=from_id,
            timeout=timeout or self.default_timeout,
        )
        n_transactions += len(tmp_transactions)
        transactions += tmp_transactions

    transactions = transactions[:max_results]

    return transactions

download_file(file, *, filename=None, folder='.', timeout=None)

Downloads a file attached to a decision and write it on disk

Parameters:

Name	Type	Description	Default
file	File	file to download	required
filename	str | None	name of the file to write the content into. If None, uses its default name. Defaults to None.	None
folder	str	name of the folder to write the file into. Defaults to "." (the current folder).	'.'
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns: str: path to downloaded file

Source code in pyjudilibre/pyjudilibre.py

def download_file(
    self,
    file: File,
    *,
    filename: str | None = None,
    folder: str = ".",
    timeout: int | None = None,
) -> str:
    """Downloads a file attached to a decision and write it on disk

    Args:
        file (File): file to download
        filename (str | None, optional): name of the file to write the content into.
            If None, uses its default name.
            Defaults to None.
        folder (str, optional): name of the folder to write the file into.
            Defaults to "." (the current folder).
        timeout (int): Number of seconds before timeout.
            Defaults to 5.
    Returns:
        str: path to downloaded file
    """

    if filename is None:
        filename = file.name

    if file.rawUrl is None:
        raise JudilibreDownloadFileError("rawUrl is not defined")

    request = urllib.request.Request(
        url=file.rawUrl,
        headers=self.client_headers,
    )

    with self.url_opener.open(
        request,
        timeout=timeout or self.default_timeout,
    ) as response:
        content: bytes = response.read()

    output_path = os.path.join(folder, filename)
    with open(output_path, "wb") as output_file:
        output_file.write(content)

    return output_path

download_decision_files(decision, types=[JudilibreFileTypeEnum.rapport_du_conseiller, JudilibreFileTypeEnum.avis_de_l_avocat_general], folder='.', timeout=None)

Download all files from a decision

Parameters:

Name	Type	Description	Default
decision	JudilibreDecision	a decision	required
types	list[JudilibreFileTypeEnum]	a list of file types. Defaults to all available file types.	[rapport_du_conseiller, avis_de_l_avocat_general]
folder	str	folder to write files into. Defaults to ".".	'.'
timeout	int	Number of seconds before timeout. Defaults to 5.	None

Returns: list[str]: list of paths to downloaded files

Source code in pyjudilibre/pyjudilibre.py

def download_decision_files(
    self,
    decision: JudilibreDecision,
    types: list[JudilibreFileTypeEnum] = [
        JudilibreFileTypeEnum.rapport_du_conseiller,
        JudilibreFileTypeEnum.avis_de_l_avocat_general,
    ],
    folder: str = ".",
    timeout: int | None = None,
) -> list[str]:
    """Download all files from a decision

    Args:
        decision (JudilibreDecision): a decision
        types (list[JudilibreFileTypeEnum], optional): a list of file types.
            Defaults to all available file types.
        folder (str, optional): folder to write files into.
            Defaults to ".".
        timeout (int): Number of seconds before timeout.
            Defaults to 5.
    Returns:
        list[str]: list of paths to downloaded files
    """
    if decision.files is None:
        return []
    files = [f for f in decision.files if f.type in types]

    filenames = []

    for f in files:
        filename = self.download_file(
            file=f,
            folder=folder,
            timeout=timeout or self.default_timeout,
        )

        filenames.append(filename)

    return filenames

JurisdictionEnum

Bases: JudilibreMultiValueEnum

Enumeration for the JURISDICTION attribute

Source code in pyjudilibre/enums.py

class JurisdictionEnum(JudilibreMultiValueEnum):
    """Enumeration for the `JURISDICTION` attribute"""

    cour_de_cassation = "Cour de cassation", "cc"
    cours_d_appel = "Cour d'appel", "ca"
    tribunaux_judiciaires = "Tribunal judiciaire", "tj"
    tribunaux_de_commerce = "Tribunal de commerce", "tcom"

LocationCAEnum

Bases: JudilibreMultiValueEnum

Enumeration for the LOCATION attribute for Cours d'appel

Source code in pyjudilibre/enums.py

class LocationCAEnum(JudilibreMultiValueEnum):
    """Enumeration for the `LOCATION` attribute for Cours d'appel"""

    ca_agen = "Cour d'appel d'Agen", "ca_agen"
    ca_aix_provence = "Cour d'appel d'Aix-en-Provence", "ca_aix_provence"
    ca_amiens = "Cour d'appel d'Amiens", "ca_amiens"
    ca_angers = "Cour d'appel d'Angers", "ca_angers"
    ca_basse_terre = "Cour d'appel de Basse-Terre", "ca_basse_terre"
    ca_bastia = "Cour d'appel de Bastia", "ca_bastia"
    ca_besancon = "Cour d'appel de Besançon", "ca_besancon"
    ca_bordeaux = "Cour d'appel de Bordeaux", "ca_bordeaux"
    ca_bourges = "Cour d'appel de Bourges", "ca_bourges"
    ca_caen = "Cour d'appel de Caen", "ca_caen"
    ca_cayenne = "Cour d'appel de Cayenne", "ca_cayenne"
    ca_chambery = "Cour d'appel de Chambéry", "ca_chambery"
    ca_colmar = "Cour d'appel de Colmar", "ca_colmar"
    ca_dijon = "Cour d'appel de Dijon", "ca_dijon"
    ca_douai = "Cour d'appel de Douai", "ca_douai"
    ca_fort_de_france = "Cour d'appel de Fort-de-France", "ca_fort_de_france"
    ca_grenoble = "Cour d'appel de Grenoble", "ca_grenoble"
    ca_limoges = "Cour d'appel de Limoges", "ca_limoges"
    ca_lyon = "Cour d'appel de Lyon", "ca_lyon"
    ca_metz = "Cour d'appel de Metz", "ca_metz"
    ca_montpellier = "Cour d'appel de Montpellier", "ca_montpellier"
    ca_nancy = "Cour d'appel de Nancy", "ca_nancy"
    ca_nimes = "Cour d'appel de Nîmes", "ca_nimes"
    ca_noumea = "Cour d'appel de Nouméa", "ca_noumea"
    ca_orleans = "Cour d'appel d'Orléans", "ca_orleans"
    ca_papeete = "Cour d'appel de Papeete", "ca_papeete"
    ca_paris = "Cour d'appel de Paris", "ca_paris"
    ca_pau = "Cour d'appel de Pau", "ca_pau"
    ca_poitiers = "Cour d'appel de Poitiers", "ca_poitiers"
    ca_reims = "Cour d'appel de Reims", "ca_reims"
    ca_rennes = "Cour d'appel de Rennes", "ca_rennes"
    ca_riom = "Cour d'appel de Riom", "ca_riom"
    ca_rouen = "Cour d'appel de Rouen", "ca_rouen"
    ca_st_denis_reunion = (
        "Cour d'appel de Saint-Denis de la Réunion",
        "ca_st_denis_reunion",
    )
    ca_toulouse = "Cour d'appel de Toulouse", "ca_toulouse"
    ca_versailles = "Cour d'appel de Versailles", "ca_versailles"

    @property
    def city(self) -> str:
        """Name of the city in which the court is located"""
        string = self.value
        replacements = [
            ("Cour d'appel de ", ""),
            ("Cour d'appel d'", ""),
            ("Cour d'appel du", "Le"),
            ("Cour d'appel des", "Les"),
        ]

        for pattern, replacement in replacements:
            string = string.replace(pattern, replacement)

        string = string.split("(")[0]
        return string.strip()

city property

Name of the city in which the court is located

LocationTJEnum

Bases: JudilibreMultiValueEnum

Enumeration for the LOCATION attribute for tribunaux judiciaires

Source code in pyjudilibre/enums.py

class LocationTJEnum(JudilibreMultiValueEnum):
    """Enumeration for the `LOCATION` attribute for tribunaux judiciaires"""

    tj_agen = "Tribunal judiciaire d'Agen", "tj47001"
    tj_aix_en_provence = "Tribunal judiciaire d'Aix-en-Provence", "tj13001"
    tj_ajaccio = "Tribunal judiciaire d'Ajaccio", "tj2a004"
    tj_albertville = "Tribunal judiciaire d'Albertville", "tj73011"
    tj_albi = "Tribunal judiciaire d'Albi", "tj81004"
    tj_alencon = "Tribunal judiciaire d'Alençon", "tj61001"
    tj_ales = "Tribunal judiciaire d'Alès", "tj30007"
    tj_amiens = "Tribunal judiciaire d'Amiens", "tj80021"
    tj_angers = "Tribunal judiciaire d'Angers", "tj49007"
    tj_angouleme = "Tribunal judiciaire d'Angoulême", "tj16015"
    tj_annecy = "Tribunal judiciaire d'Annecy", "tj74010"
    tj_argentan = "Tribunal judiciaire d'Argentan", "tj61006"
    tj_arras = "Tribunal judiciaire d'Arras", "tj62041"
    tj_auch = "Tribunal judiciaire d'Auch", "tj32013"
    tj_aurillac = "Tribunal judiciaire d'Aurillac", "tj15014"
    tj_auxerre = "Tribunal judiciaire d'Auxerre", "tj89024"
    tj_avesnes_sur_helpe = "Tribunal judiciaire d'Avesnes-sur-Helpe", "tj59036"
    tj_avignon = "Tribunal judiciaire d'Avignon", "tj84007"
    tj_bar_le_duc = "Tribunal judiciaire de Bar-le-Duc", "tj55029"
    tj_basse_terre = "Tribunal judiciaire de Basse-Terre", "tj97105"
    tj_bastia = "Tribunal judiciaire de Bastia", "tj2b033"
    tj_bayonne = "Tribunal judiciaire de Bayonne", "tj64102"
    tj_beauvais = "Tribunal judiciaire de Beauvais", "tj60057"
    tj_belfort = "Tribunal judiciaire de Belfort", "tj90010"
    tj_bergerac = "Tribunal judiciaire de Bergerac", "tj24037"
    tj_besancon = "Tribunal judiciaire de Besançon", "tj25056"
    tj_bethune = "Tribunal judiciaire de Béthune", "tj62119"
    tj_beziers = "Tribunal judiciaire de Béziers", "tj34032"
    tj_blois = "Tribunal judiciaire de Blois", "tj41018"
    tj_bobigny = "Tribunal judiciaire de Bobigny", "tj93008"
    tj_bonneville = "Tribunal judiciaire de Bonneville", "tj74042"
    tj_bordeaux = "Tribunal judiciaire de Bordeaux", "tj33063"
    tj_boulogne_sur_mer = "Tribunal judiciaire de Boulogne-sur-Mer", "tj62160"
    tj_bourg_en_bresse = "Tribunal judiciaire de Bourg-en-Bresse", "tj01053"
    tj_bourges = "Tribunal judiciaire de Bourges", "tj18033"
    tj_bourgoin_jallieu = "Tribunal judiciaire de Bourgoin-Jallieu", "tj38053"
    tj_brest = "Tribunal judiciaire de Brest", "tj29019"
    tj_brive_la_gaillarde = "Tribunal judiciaire de Brive-la-Gaillarde", "tj19031"
    tj_caen = "Tribunal judiciaire de Caen", "tj14118"
    tj_cahors = "Tribunal judiciaire de Cahors", "tj46042"
    tj_cambrai = "Tribunal judiciaire de Cambrai", "tj59122"
    tj_carcassonne = "Tribunal judiciaire de Carcassonne", "tj11069"
    tj_carpentras = "Tribunal judiciaire de Carpentras", "tj84031"
    tj_castres = "Tribunal judiciaire de Castres", "tj81065"
    tj_cayenne = "Tribunal judiciaire de Cayenne", "tj97302"
    tj_chalon_sur_saone = "Tribunal judiciaire de Chalon-sur-Saône", "tj71076"
    tj_chalons_en_champagne = "Tribunal judiciaire de Chalons-en-Champagne", "tj51108"
    tj_chambery = "Tribunal judiciaire de Chambéry", "tj73065"
    tj_charleville_mezieres = "Tribunal judiciaire de Charleville-Mézières", "tj08105"
    tj_chartres = "Tribunal judiciaire de Chartres", "tj28085"
    tj_chateauroux = "Tribunal judiciaire de Châteauroux", "tj36044"
    tj_chaumont = "Tribunal judiciaire de Chaumont", "tj52121"
    tj_cherbourg_en_cotentin = "Tribunal judiciaire de Cherbourg-en-Cotentin", "tj50129"
    tj_clermont_ferrand = "Tribunal judiciaire de Clermont-Ferrand", "tj63113"
    tj_colmar = "Tribunal judiciaire de Colmar", "tj68066"
    tj_compiegne = "Tribunal judiciaire de Compiègne", "tj60159"
    tj_coutances = "Tribunal judiciaire de Coutances", "tj50147"
    tj_creteil = "Tribunal judiciaire de Créteil", "tj94028"
    tj_cusset = "Tribunal judiciaire de Cusset", "tj03095"
    tj_dax = "Tribunal judiciaire de Dax", "tj40088"
    tj_dieppe = "Tribunal judiciaire de Dieppe", "tj76217"
    tj_digne_les_bains = "Tribunal judiciaire de Digne-les-Bains", "tj04070"
    tj_dijon = "Tribunal judiciaire de Dijon", "tj21231"
    tj_dole = "Tribunal judiciaire de Dole (chambre détachée)", "tj39198"
    tj_douai = "Tribunal judiciaire de Douai", "tj59178"
    tj_draguignan = "Tribunal judiciaire de Draguignan", "tj83050"
    tj_dunkerque = "Tribunal judiciaire de Dunkerque", "tj59183"
    tj_epinal = "Tribunal judiciaire d'Épinal", "tj88160"
    tj_evreux = "Tribunal judiciaire d'Évreux", "tj27229"
    tj_evry = "Tribunal judiciaire d'Évry", "tj91228"
    tj_foix = "Tribunal judiciaire de Foix", "tj09122"
    tj_fontainebleau = "Tribunal judiciaire de Fontainebleau", "tj77186"
    tj_fort_de_france = "Tribunal judiciaire de Fort-de-France", "tj97209"
    tj_gap = "Tribunal judiciaire de Gap", "tj05061"
    tj_grasse = "Tribunal judiciaire de Grasse", "tj06069"
    tj_grenoble = "Tribunal judiciaire de Grenoble", "tj38185"
    tj_gueret = "Tribunal judiciaire de Guéret", "tj23096"
    tj_guingamp = "Tribunal judiciaire de Guingamp (chambre détachée)", "tj22070"
    tj_kone = "Tribunal judiciaire de Kone (section détachée)", "tj98811"
    tj_la_roche_sur_yon = "Tribunal judiciaire de La Roche-sur-Yon", "tj85191"
    tj_la_rochelle = "Tribunal judiciaire de La Rochelle", "tj17300"
    tj_laon = "Tribunal judiciaire de Laon", "tj02408"
    tj_laval = "Tribunal judiciaire de Laval", "tj53130"
    tj_havre = "Tribunal judiciaire du Havre", "tj76351"
    tj_mans = "Tribunal judiciaire du Mans", "tj72181"
    tj_puy_en_velay = "Tribunal judiciaire du Puy-en-Velay", "tj43157"
    tj_sables_d_olonne = "Tribunal judiciaire des Sables-d'Olonne", "tj85194"
    tj_libourne = "Tribunal judiciaire de Libourne", "tj33243"
    tj_lille = "Tribunal judiciaire de Lille", "tj59350"
    tj_limoges = "Tribunal judiciaire de Limoges", "tj87085"
    tj_lisieux = "Tribunal judiciaire de Lisieux", "tj14366"
    tj_lons_le_saunier = "Tribunal judiciaire de Lons-le-Saunier", "tj39300"
    tj_lorient = "Tribunal judiciaire de Lorient", "tj56121"
    tj_lyon = "Tribunal judiciaire de Lyon", "tj69123"
    tj_macon = "Tribunal judiciaire de Mâcon", "tj71270"
    tj_mamoudzou = "Tribunal judiciaire de Mamoudzou", "tj97611"
    tj_marmande = "Tribunal judiciaire de Marmande (chambre détachée)", "tj47157"
    tj_marseille = "Tribunal judiciaire de Marseille", "tj13055"
    tj_mata_utu = "Tribunal judiciaire de Mata-Utu", "tj98613"
    tj_meaux = "Tribunal judiciaire de Meaux", "tj77291", "tj77284"
    tj_melun = "Tribunal judiciaire de Melun", "tj77288"
    tj_mende = "Tribunal judiciaire de Mende", "tj48095"
    tj_metz = "Tribunal judiciaire de Metz", "tj57463"
    tj_millau = "Tribunal judiciaire de Millau (chambre détachée)", "tj12145"
    tj_mont_de_marsan = "Tribunal judiciaire de Mont-de-Marsan", "tj40192"
    tj_montargis = "Tribunal judiciaire de Montargis", "tj45208"
    tj_montauban = "Tribunal judiciaire de Montauban", "tj82121"
    tj_montbeliard = "Tribunal judiciaire de Montbéliard", "tj25388"
    tj_montlucon = "Tribunal judiciaire de Montluçon", "tj03185"
    tj_montpellier = "Tribunal judiciaire de Montpellier", "tj34172"
    tj_moulins = "Tribunal judiciaire de Moulins", "tj03190"
    tj_mulhouse = "Tribunal judiciaire de Mulhouse", "tj68224"
    tj_nancy = "Tribunal judiciaire de Nancy", "tj54395"
    tj_nanterre = "Tribunal judiciaire de Nanterre", "tj92050"
    tj_nantes = "Tribunal judiciaire de Nantes", "tj44109"
    tj_narbonne = "Tribunal judiciaire de Narbonne", "tj11262"
    tj_nevers = "Tribunal judiciaire de Nevers", "tj58194"
    tj_nice = "Tribunal judiciaire de Nice", "tj06088"
    tj_nimes = "Tribunal judiciaire de Nîmes", "tj30189"
    tj_niort = "Tribunal judiciaire de Niort", "tj79191"
    tj_noumea = "Tribunal judiciaire de Nouméa", "tj98818"
    tj_orleans = "Tribunal judiciaire d'Orléans", "tj45234"
    tj_papeete = "Tribunal judiciaire de Papeete", "tj98735"
    tj_paris = "Tribunal judiciaire de Paris", "tj75056"
    tj_pau = "Tribunal judiciaire de Pau", "tj64445"
    tj_perigueux = "Tribunal judiciaire de Périgueux", "tj24322"
    tj_perpignan = "Tribunal judiciaire de Perpignan", "tj66136"
    tj_pointe_a_pitre = "Tribunal judiciaire de Pointe-à-Pitre", "tj97120"
    tj_poitiers = "Tribunal judiciaire de Poitiers", "tj86194"
    tj_pontoise = "Tribunal judiciaire de Pontoise", "tj95500"
    tj_privas = "Tribunal judiciaire de Privas", "tj07186"
    tj_quimper = "Tribunal judiciaire de Quimper", "tj29232"
    tj_reims = "Tribunal judiciaire de Reims", "tj51454"
    tj_rennes = "Tribunal judiciaire de Rennes", "tj35238"
    tj_roanne = "Tribunal judiciaire de Roanne", "tj42187"
    tj_rodez = "Tribunal judiciaire de Rodez", "tj12202"
    tj_rouen = "Tribunal judiciaire de Rouen", "tj76540"
    tj_saint_brieuc = "Tribunal judiciaire de Saint-Brieuc", "tj22278"
    tj_saint_denis_de_la_reunion = "Tribunal judiciaire de Saint-Denis de La Réunion", "tj97411"
    tj_saint_etienne = "Tribunal judiciaire de Saint-Etienne", "tj42218"
    tj_saint_gaudens = "Tribunal judiciaire de Saint-Gaudens", "tj31483"
    tj_saint_malo = "Tribunal judiciaire de Saint-Malo", "tj35288"
    tj_saint_nazaire = "Tribunal judiciaire de Saint-Nazaire", "tj44184"
    tj_saint_omer = "Tribunal judiciaire de Saint-Omer", "tj62765"
    tj_saint_pierre_de_la_reunion = "Tribunal judiciaire de Saint-Pierre de La Réunion", "tj97416"
    tj_saint_quentin = "Tribunal judiciaire de Saint-Quentin", "tj02691"
    tj_saint_laurent_du_maroni = "Tribunal judiciaire de Saint-Laurent-Du-Maroni (chambre détachée)", "tj97311"
    tj_saint_martin = "Tribunal judiciaire de Saint-Martin (chambre détachée)", "tj97801"
    tj_sarreguemines = "Tribunal judiciaire de Sarreguemines", "tj57631"
    tj_saumur = "Tribunal judiciaire de Saumur", "tj49328"
    tj_saverne = "Tribunal judiciaire de Saverne", "tj67437"
    tj_senlis = "Tribunal judiciaire de Senlis", "tj60612"
    tj_sens = "Tribunal judiciaire de Sens", "tj89387"
    tj_soissons = "Tribunal judiciaire de Soissons", "tj02722"
    tj_strasbourg = "Tribunal judiciaire de Strasbourg", "tj67482"
    tj_tarascon = "Tribunal judiciaire de Tarascon", "tj13108"
    tj_tarbes = "Tribunal judiciaire de Tarbes", "tj65440"
    tj_thionville = "Tribunal judiciaire de Thionville", "tj57672"
    tj_thonon_les_bains = "Tribunal judiciaire de Thonon-les-Bains", "tj74281"
    tj_toulon = "Tribunal judiciaire de Toulon", "tj83137"
    tj_toulouse = "Tribunal judiciaire de Toulouse", "tj31555"
    tj_tours = "Tribunal judiciaire de Tours", "tj37261"
    tj_troyes = "Tribunal judiciaire de Troyes", "tj10387"
    tj_tulle = "Tribunal judiciaire de Tulle", "tj19272"
    tj_val_de_briey = "Tribunal judiciaire de Val de Briey", "tj54099"
    tj_valence = "Tribunal judiciaire de Valence", "tj26362"
    tj_valenciennes = "Tribunal judiciaire de Valenciennes", "tj59606"
    tj_vannes = "Tribunal judiciaire de Vannes", "tj56260"
    tj_verdun = "Tribunal judiciaire de Verdun", "tj55545"
    tj_versailles = "Tribunal judiciaire de Versailles", "tj78646"
    tj_vesoul = "Tribunal judiciaire de Vesoul", "tj70550"
    tj_vienne = "Tribunal judiciaire de Vienne", "tj38544"
    tj_villefranche_sur_saone = "Tribunal judiciaire de Villefranche-sur-Saône", "tj69264"

    @property
    def city(self) -> str:
        """Name of the city in which the court is located"""
        string = self.value
        replacements = [
            ("Tribunal judiciaire de ", ""),
            ("Tribunal judiciaire d'", ""),
            ("Tribunal judiciaire du", "Le"),
            ("Tribunal judiciaire des", "Les"),
        ]

        for pattern, replacement in replacements:
            string = string.replace(pattern, replacement)

        string = string.split("(")[0]
        return string.strip()

city property

Name of the city in which the court is located

LocationTCOMEnum

Bases: JudilibreMultiValueEnum

Enumeration for the LOCATION attribute for tribunaux de commerce

Source code in pyjudilibre/enums.py

class LocationTCOMEnum(JudilibreMultiValueEnum):
    """Enumeration for the `LOCATION` attribute for tribunaux de commerce"""

    tcom_agen = "Tribunal de commerce d'Agen", "4701"
    tcom_aix_en_provence = "Tribunal de commerce d'Aix-en-Provence", "1301"
    tcom_ajaccio = "Tribunal de commerce d'Ajaccio", "2001"
    tcom_albi = "Tribunal de commerce d'Albi", "8101"
    tcom_alencon = "Tribunal de commerce d'Alençon", "6101"
    tcom_amiens = "Tribunal de commerce d'Amiens", "8002"
    tcom_angers = "Tribunal de commerce d'Angers", "4901"
    tcom_angouleme = "Tribunal de commerce d'Angoulême", "1601"
    tcom_annecy = "Tribunal de commerce d'Annecy", "7401"
    tcom_antibes = "Tribunal de commerce d'Antibes", "0601"
    tcom_arras = "Tribunal de commerce d'Arras", "6201"
    tcom_aubenas = "Tribunal de commerce d'Aubenas", "0702"
    tcom_auch = "Tribunal de commerce d'Auch", "3201"
    tcom_aurillac = "Tribunal de commerce d'Aurillac", "1501"
    tae_d_auxerre = "Tribunal des activités économiques d'Auxerre", "8901"
    tae_d_avignon = "Tribunal des activités économiques d'Avignon", "8401"
    tcom_bar_le_duc = "Tribunal de commerce de Bar-le-Duc", "5501"
    tcom_basse_terre = "Tribunal de commerce de Basse-Terre", "9711"
    tcom_bastia = "Tribunal de commerce de Bastia", "2002"
    tcom_bayonne = "Tribunal de commerce de Bayonne", "6401"
    tcom_beauvais = "Tribunal de commerce de Beauvais", "6001"
    tcom_belfort = "Tribunal de commerce de Belfort", "9001"
    tcom_bergerac = "Tribunal de commerce de Bergerac", "2401"
    tcom_bernay = "Tribunal de commerce de Bernay", "2701"
    tcom_besancon = "Tribunal de commerce de Besançon", "2501"
    tcom_beziers = "Tribunal de commerce de Béziers", "3402"
    tcom_blois = "Tribunal de commerce de Blois", "4101"
    tcom_bobigny = "Tribunal de commerce de Bobigny", "9301"
    tcom_bordeaux = "Tribunal de commerce de Bordeaux", "3302"
    tcom_boulogne_sur_mer = "Tribunal de commerce de Boulogne-sur-Mer", "6202"
    tcom_bourg_en_bresse = "Tribunal de commerce de Bourg-en-Bresse", "0101"
    tcom_bourges = "Tribunal de commerce de Bourges", "1801"
    tcom_brest = "Tribunal de commerce de Brest", "2901"
    tcom_briey = "Tribunal de commerce de Briey", "5401"
    tcom_brive_la_gaillarde = "Tribunal de commerce de Brive-la-Gaillarde", "1901"
    tcom_caen = "Tribunal de commerce de Caen", "1402"
    tcom_cahors = "Tribunal de commerce de Cahors", "4601"
    tcom_cannes = "Tribunal de commerce de Cannes", "0602"
    tcom_carcassonne = "Tribunal de commerce de Carcassonne", "1101"
    tcom_castres = "Tribunal de commerce de Castres", "8102"
    tcom_cayenne = "Tribunal de commerce de Cayenne", "9731"
    tcom_chalon_sur_saone = "Tribunal de commerce de Chalon-sur-Saône", "7102"
    tcom_chalons_en_champagne = "Tribunal de commerce de Chalons-en-Champagne", "5101"
    tcom_chambery = "Tribunal de commerce de Chambéry", "7301"
    tcom_chartres = "Tribunal de commerce de Chartres", "2801"
    tcom_chateauroux = "Tribunal de commerce de Châteauroux", "3601"
    tcom_chaumont = "Tribunal de commerce de Chaumont", "5201"
    tcom_cherbourg = "Tribunal de commerce de Cherbourg", "5001"
    tcom_clermont_ferrand = "Tribunal de commerce de Clermont-Ferrand", "6303"
    tcom_compiegne = "Tribunal de commerce de Compiègne", "6002"
    tcom_coutances = "Tribunal de commerce de Coutances", "5002"
    tcom_creteil = "Tribunal de commerce de Créteil", "9401"
    tcom_cusset = "Tribunal de commerce de Cusset", "0301"
    tcom_dax = "Tribunal de commerce de Dax", "4001"
    tcom_dieppe = "Tribunal de commerce de Dieppe", "7601"
    tcom_dijon = "Tribunal de commerce de Dijon", "2104"
    tcom_douai = "Tribunal de commerce de Douai", "5952"
    tcom_draguignan = "Tribunal de commerce de Draguignan", "8302"
    tcom_dunkerque = "Tribunal de commerce de Dunkerque", "5902"
    tcom_epinal = "Tribunal de commerce d'Épinal", "8801"
    tcom_evreux = "Tribunal de commerce d'Évreux", "2702"
    tcom_evry = "Tribunal de commerce d'Évry", "7801"
    tcom_foix = "Tribunal de commerce de Foix", "0901"
    tcom_fort_de_france = "Tribunal de commerce de Fort-de-France", "9721"
    tcom_frejus = "Tribunal de commerce de Fréjus", "8303"
    tcom_gap = "Tribunal de commerce de Gap", "0501"
    tcom_grasse = "Tribunal de commerce de Grasse", "0603"
    tcom_grenoble = "Tribunal de commerce de Grenoble", "3801"
    tcom_gueret = "Tribunal de commerce de Guéret", "2301"
    tcom_la_roche_sur_yon = "Tribunal de commerce de La Roche-sur-Yon", "8501"
    tcom_la_rochelle = "Tribunal de commerce de La Rochelle", "1704"
    tcom_laval = "Tribunal de commerce de Laval", "5301"
    tae_du_havre = "Tribunal des activités économiques du Havre", "7606"
    tae_du_mans = "Tribunal des activités économiques du Mans", "7202"
    tcom_puy_en_velay = "Tribunal de commerce du Puy-en-Velay", "4302"
    tcom_libourne = "Tribunal de commerce de Libourne", "3303"
    tcom_lille_metropole = "Tribunal de commerce de Lille Métropole", "5910"
    tae_de_limoges = "Tribunal des activités économiques de Limoges", "8701"
    tcom_lisieux = "Tribunal de commerce de Lisieux", "1407"
    tcom_lons_le_saunier = "Tribunal de commerce de Lons-le-Saunier", "3902"
    tcom_lorient = "Tribunal de commerce de Lorient", "5601"
    tae_de_lyon = "Tribunal des activités économiques de Lyon", "6901"
    tcom_macon = "Tribunal de commerce de Mâcon", "7106"
    tcom_mamoudzou = "Tribunal de commerce de Mamoudzou", "9761"
    tcom_manosque = "Tribunal de commerce de Manosque", "0401"
    tae_de_marseille = "Tribunal des activités économiques de Marseille", "1303"
    tcom_meaux = "Tribunal de commerce de Meaux", "7701"
    tcom_melun = "Tribunal de commerce de Melun", "7702"
    tcom_mende = "Tribunal de commerce de Mende", "4801"
    tcom_mont_de_marsan = "Tribunal de commerce de Mont-de-Marsan", "4002"
    tcom_montauban = "Tribunal de commerce de Montauban", "8201"
    tcom_montlucon = "Tribunal de commerce de Montluçon", "0303"
    tcom_montpellier = "Tribunal de commerce de Montpellier", "3405"
    tae_de_nancy = "Tribunal des activités économiques de Nancy", "5402"
    tae_de_nanterre = "Tribunal des activités économiques de Nanterre", "9201"
    tcom_nantes = "Tribunal de commerce de Nantes", "4401"
    tcom_narbonne = "Tribunal de commerce de Narbonne", "1104"
    tcom_nevers = "Tribunal de commerce de Nevers", "5802"
    tcom_nice = "Tribunal de commerce de Nice", "0605"
    tcom_nimes = "Tribunal de commerce de Nîmes", "3003"
    tcom_niort = "Tribunal de commerce de Niort", "7901"
    tcom_orleans = "Tribunal de commerce d'Orléans", "4502"
    tae_de_paris = "Tribunal des activités économiques de Paris", "7501"
    tcom_pau = "Tribunal de commerce de Pau", "6403"
    tcom_perigueux = "Tribunal de commerce de Périgueux", "2402"
    tcom_perpignan = "Tribunal de commerce de Perpignan", "6601"
    tcom_pointe_a_pitre = "Tribunal de commerce de Pointe-à-Pitre", "9712"
    tcom_poitiers = "Tribunal de commerce de Poitiers", "8602"
    tcom_pontoise = "Tribunal de commerce de Pontoise", "7802"
    tcom_quimper = "Tribunal de commerce de Quimper", "2903"
    tcom_reims = "Tribunal de commerce de Reims", "5103"
    tcom_rennes = "Tribunal de commerce de Rennes", "3501"
    tcom_roanne = "Tribunal de commerce de Roanne", "4201"
    tcom_rodez = "Tribunal de commerce de Rodez", "1203"
    tcom_romans = "Tribunal de commerce de Romans", "2602"
    tcom_rouen = "Tribunal de commerce de Rouen", "7608"
    tae_de_saint_brieuc = "Tribunal des activités économiques de Saint-Brieuc", "2202"
    tcom_saint_denis_de_la_reunion = "Tribunal de commerce de Saint-Denis de La Réunion", "9741"
    tcom_saint_etienne = "Tribunal de commerce de Saint-Etienne", "4202"
    tcom_saint_malo = "Tribunal de commerce de Saint-Malo", "3502"
    tcom_saint_nazaire = "Tribunal de commerce de Saint-Nazaire", "4402"
    tcom_saint_pierre_de_la_reunion = "Tribunal de commerce de Saint-Pierre de La Réunion", "9742"
    tcom_saint_quentin = "Tribunal de commerce de Saint-Quentin", "0202"
    tcom_saintes = "Tribunal de commerce de Saintes", "1708"
    tcom_salon_de_provence = "Tribunal de commerce de Salon-de-Provence", "1304"
    tcom_sedan = "Tribunal de commerce de Sedan", "0802"
    tcom_sens = "Tribunal de commerce de Sens", "8903"
    tcom_soissons = "Tribunal de commerce de Soissons", "0203"
    tcom_tarascon = "Tribunal de commerce de Tarascon", "1305"
    tcom_tarbes = "Tribunal de commerce de Tarbes", "6502"
    tcom_thonon_les_bains = "Tribunal de commerce de Thonon-les-Bains", "7402"
    tcom_toulon = "Tribunal de commerce de Toulon", "8305"
    tcom_toulouse = "Tribunal de commerce de Toulouse", "3102"
    tcom_tours = "Tribunal de commerce de Tours", "3701"
    tcom_troyes = "Tribunal de commerce de Troyes", "1001"
    tcom_valenciennes = "Tribunal de commerce de Valenciennes", "5906"
    tcom_vannes = "Tribunal de commerce de Vannes", "5602"
    tcom_vesoul___gray = "Tribunal de commerce de Vesoul - Gray", "7001"
    tae_de_versailles = "Tribunal des activités économiques de Versailles", "7803"
    tcom_vienne = "Tribunal de commerce de Vienne", "3802"
    tcom_villefranche_sur_saone___tarare = "Tribunal de commerce de Villefranche-sur-Saône - Tarare", "6903"

    @property
    def city(self) -> str:
        """Name of the city in which the court is located"""
        string = self.value
        replacements = [
            ("Tribunal de commerce de ", ""),
            ("Tribunal de commerce d'", ""),
            ("Tribunal de commerce du", "Le"),
            ("Tribunal de commerce des", "Les"),
            ("Tribunal des activités économiques de ", ""),
            ("Tribunal des activités économiques d'", ""),
            ("Tribunal des activités économiques du", "Le"),
            ("Tribunal des activités économiques des", "Les"),
        ]

        for pattern, replacement in replacements:
            string = string.replace(pattern, replacement)

        string = string.split("(")[0]
        return string.strip()

city property

Name of the city in which the court is located

JudilibreDecision

Bases: JudilibreShortDecision

Source code in pyjudilibre/models.py

class JudilibreDecision(JudilibreShortDecision):
    model_config = ConfigDict(extra="forbid")
    """Class representing a full Judilibre Decision"""

    source: SourceEnum
    text: str
    update_date: str
    update_datetime: str | None = None
    # decision_datetime: str | None = None
    themes: list[str] | None = None
    # nac: str | None = None
    # portalis: str | None = None
    zones: Zones | None = None
    contested: ShortDecision | None = None
    forward: str | dict | None = None
    timeline: list[ShortDecision] | None = None
    partial: bool | None = None
    visa: list[Article] | None = None
    rapprochements: list[Article] | None = None
    legacy: Legacy | None = None

    @property
    def zoning(self):
        return Zoning(text=self.text, zones=self.zones)

model_config = ConfigDict(extra='forbid') class-attribute instance-attribute

Class representing a full Judilibre Decision

JudilibreSearchResult

Bases: JudilibreShortDecision

Source code in pyjudilibre/models.py

class JudilibreSearchResult(JudilibreShortDecision):
    model_config = ConfigDict(extra="forbid")
    """Class representing Search Results"""

    score: float
    highlights: Highlights

model_config = ConfigDict(extra='forbid') class-attribute instance-attribute

Class representing Search Results

JudilibreStatsResults

Bases: BaseModel

Class representing Aggregation results

Source code in pyjudilibre/models.py

class JudilibreStatsResults(BaseModel):
    """Class representing Aggregation results"""

    model_config = ConfigDict(extra="forbid")

    min_decision_date: datetime.date | None = None
    max_decision_date: datetime.date | None = None
    total_decisions: int | None = None
    aggregated_data: list[JudilibreAggregatedData] = []