API Reference

Complete API documentation for the Nukat client.

Nukat(timeout=30)

Client for searching the NUKAT library catalog.

Example usage

client = Nukat() results = client.search("Python programming") for result in results: print(result['title'])

Initialize the NUKAT client.

Parameters:

Name	Type	Description	Default
timeout	int	Timeout for HTTP requests in seconds (default 30)	30

Source code in nukat/client.py

def __init__(self, timeout: int = 30):
    """Initialize the NUKAT client.

    Args:
        timeout: Timeout for HTTP requests in seconds (default 30)
    """
    self.timeout = timeout
    self.session = requests.Session()
    self.session.headers.update({"User-Agent": "NukatClient/0.1.0 (Python)"})

search(query, limit=20, offset=0, index=None, sort_by=None, language=None, document_type=None, year_from=None, year_to=None)

Search the NUKAT catalog.

Parameters:

Name	Type	Description	Default
query	str	Search query	required
limit	int	Maximum number of results per page (default 20, max 100)	20
offset	int	Result offset (default 0)	0
index	Optional[str]	Search type (e.g. 'ti' for title, 'au' for author)	None
sort_by	Optional[str]	Result sorting method	None
language	Optional[str]	Language filter	None
document_type	Optional[str]	Document type filter	None
year_from	Optional[int]	Start year of date range	None
year_to	Optional[int]	End year of date range	None

Returns:

Type	Description
List[Dict[str, Any]]	List of dictionaries with search results

Source code in nukat/client.py

def search(
    self,
    query: str,
    limit: int = 20,
    offset: int = 0,
    index: Optional[str] = None,
    sort_by: Optional[str] = None,
    language: Optional[str] = None,
    document_type: Optional[str] = None,
    year_from: Optional[int] = None,
    year_to: Optional[int] = None,
) -> List[Dict[str, Any]]:
    """Search the NUKAT catalog.

    Args:
        query: Search query
        limit: Maximum number of results per page (default 20, max 100)
        offset: Result offset (default 0)
        index: Search type (e.g. 'ti' for title, 'au' for author)
        sort_by: Result sorting method
        language: Language filter
        document_type: Document type filter
        year_from: Start year of date range
        year_to: End year of date range

    Returns:
        List of dictionaries with search results
    """
    # Maximum 100 results per page
    if limit > 100:
        limit = 100

    params = self._build_search_params(
        query=query,
        limit=limit,
        offset=offset,
        index=index,
        sort_by=sort_by,
        language=language,
        document_type=document_type,
        year_from=year_from,
        year_to=year_to,
    )

    url = urljoin(self.BASE_URL, self.SEARCH_PATH)

    try:
        response = self.session.get(url, params=params, timeout=self.timeout)
        response.raise_for_status()
        return self._parse_search_results(response.text)
    except requests.RequestException as e:
        raise NukatError(f"Error during search: {e}") from e

search_all(query, max_results=None, page_size=100, **kwargs)

Fetch all search results using pagination.

Parameters:

Name	Type	Description	Default
query	str	Search query	required
max_results	Optional[int]	Maximum number of results to fetch (None = all)	None
page_size	int	Number of results per page (max 100)	100
**kwargs	Any	Additional parameters passed to search()	{}

Returns:

Type	Description
List[Dict[str, Any]]	List of all search results

Source code in nukat/client.py

def search_all(
    self, query: str, max_results: Optional[int] = None, page_size: int = 100, **kwargs: Any
) -> List[Dict[str, Any]]:
    """Fetch all search results using pagination.

    Args:
        query: Search query
        max_results: Maximum number of results to fetch (None = all)
        page_size: Number of results per page (max 100)
        **kwargs: Additional parameters passed to search()

    Returns:
        List of all search results
    """
    all_results = []
    offset = 0

    while True:
        # Fetch page of results
        results = self.search(query=query, limit=page_size, offset=offset, **kwargs)

        if not results:
            # End of results
            break

        all_results.extend(results)

        # Check if we reached the limit
        if max_results and len(all_results) >= max_results:
            all_results = all_results[:max_results]
            break

        # Move to next page
        offset += page_size

        # If we got fewer results than page size, we're done
        if len(results) < page_size:
            break

    return all_results

search_by_author(author, **kwargs)

Search by author.

Parameters:

Name	Type	Description	Default
author	str	Author name	required
**kwargs	Any	Additional parameters passed to search()	{}

Returns:

Type	Description
List[Dict[str, Any]]	List of search results

Source code in nukat/client.py

def search_by_author(self, author: str, **kwargs: Any) -> List[Dict[str, Any]]:
    """Search by author.

    Args:
        author: Author name
        **kwargs: Additional parameters passed to search()

    Returns:
        List of search results
    """
    return self.search(query=author, index="au", **kwargs)

search_by_title(title, **kwargs)

Search by title.

Parameters:

Name	Type	Description	Default
title	str	Publication title	required
**kwargs	Any	Additional parameters passed to search()	{}

Returns:

Type	Description
List[Dict[str, Any]]	List of search results

Source code in nukat/client.py

def search_by_title(self, title: str, **kwargs: Any) -> List[Dict[str, Any]]:
    """Search by title.

    Args:
        title: Publication title
        **kwargs: Additional parameters passed to search()

    Returns:
        List of search results
    """
    return self.search(query=title, index="ti", **kwargs)

search_by_isbn(isbn, **kwargs)

Search by ISBN number.

Parameters:

Name	Type	Description	Default
isbn	str	ISBN number	required
**kwargs	Any	Additional parameters passed to search()	{}

Returns:

Type	Description
List[Dict[str, Any]]	List of search results

Source code in nukat/client.py

def search_by_isbn(self, isbn: str, **kwargs: Any) -> List[Dict[str, Any]]:
    """Search by ISBN number.

    Args:
        isbn: ISBN number
        **kwargs: Additional parameters passed to search()

    Returns:
        List of search results
    """
    return self.search(query=isbn, index="nb", **kwargs)

search_by_subject(subject, **kwargs)

Search by subject.

Parameters:

Name	Type	Description	Default
subject	str	Subject/topic heading	required
**kwargs	Any	Additional parameters passed to search()	{}

Returns:

Type	Description
List[Dict[str, Any]]	List of search results

Source code in nukat/client.py

def search_by_subject(self, subject: str, **kwargs: Any) -> List[Dict[str, Any]]:
    """Search by subject.

    Args:
        subject: Subject/topic heading
        **kwargs: Additional parameters passed to search()

    Returns:
        List of search results
    """
    return self.search(query=subject, index="su", **kwargs)

get_record_details(record_id)

Fetch detailed information about a record.

Parameters:

Name	Type	Description	Default
record_id	str	Record ID (biblionumber)	required

Returns:

Type	Description
Dict[str, Any]	Dictionary with detailed record information

Source code in nukat/client.py

def get_record_details(self, record_id: str) -> Dict[str, Any]:
    """Fetch detailed information about a record.

    Args:
        record_id: Record ID (biblionumber)

    Returns:
        Dictionary with detailed record information
    """
    url = urljoin(self.BASE_URL, f"/cgi-bin/koha/opac-detail.pl?biblionumber={record_id}")

    try:
        response = self.session.get(url, timeout=self.timeout)
        response.raise_for_status()
        return self._parse_record_details(response.text)
    except requests.RequestException as e:
        raise NukatError(f"Error fetching record details: {e}") from e

NukatError

Bases: Exception

Exception for NUKAT client errors.