kystdatahuset-python-lib 0.9.5__py3-none-any.whl

kystdatahuset/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.9.5"

kystdatahuset/ais.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+from typing import Dict, List
+from kystdatahuset.api_client import post_api
+
+def get_ais_positions_within_geom_time(
+    jwt_token: str,
+    geometry: str,
+    start_time: datetime,
+    end_time: datetime,
+) -> List[Dict]:
+    """
+    Placeholder for getting AIS positions for a given geometry and time range.
+    """
+    response = post_api(
+        jwt_token=jwt_token,
+        fragment="api/ais/positions/within-geom-time",
+        payload={
+            "geom": geometry,
+            "start": start_time.isoformat(),
+            "end": end_time.isoformat(),
+            "minSpeed": 0,
+        },
+    )
+    
+    # This is a placeholder implementation.
+    if (response is None) or (not response["success"]):
+        raise Exception(f"Failed to get AIS positions: {response['msg'] if response else 'No response'}")
+    
+    return response["data"]

kystdatahuset/api_client.py

@@ -0,0 +1,103 @@
+from typing import Any, Dict, List, Tuple, Optional
+
+from kystdatahuset.models import WebServiceResponse
+from .const import API_URL
+import requests
+from kystdatahuset.logging import logger
+
+def get_headers(jwt_token: Optional[str] = None, json: bool = False) -> Dict[str, str]:
+    """
+    Build headers for API requests.
+    """
+    headers: Dict[str, str] = {}
+    if jwt_token:
+        headers["Authorization"] = f"Bearer {jwt_token}"
+    if json:
+        headers["Content-Type"] = "application/json"
+        headers["Accept"] = "application/json"
+    return headers
+
+
+def post_api_formdata(jwt_token: str, fragment: str, data: List[Tuple[str, Any]], filename: str) -> WebServiceResponse:
+    """
+    POST multipart/form-data with a file and form fields.
+    """
+    url = f"{API_URL}/{fragment}"
+
+    with open(filename, "rb") as f:
+        files = {"file": (filename, f, "application/octet-stream")}
+        response = requests.post(url, headers=get_headers(jwt_token), data=data, files=files)
+
+    if response.ok:
+        try:
+            logger.info(f"✅ POST (FormData) {url} successful!")
+            data = response.json()
+            return data
+        except ValueError:            
+            return WebServiceResponse[Any](**{"success": True, "msg": response.text, "data": None})
+    else:
+        logger.error(f"❌ POST (FormData) {url} failed with {response.status_code}")
+        logger.debug(response.text)
+        raise Exception(f"API POST (FormData) failed with status code {response.status_code}: {response.text}")
+
+
+def get_api(jwt_token: str, fragment: str, params: Optional[Dict[str, Any]] = None) -> WebServiceResponse:
+    """
+    Perform a GET request and parse JSON response.
+    """
+    url = f"{API_URL}/{fragment}"
+    response = requests.get(url, headers=get_headers(jwt_token, json=True), params=params)
+
+    if response.ok:
+        logger.info(f"✅ GET {url} successful!")
+        try:
+            data = response.json()
+            logger.debug(f"Response JSON: {data}")
+            return data
+        except ValueError:
+            return WebServiceResponse[str](**{"success": True, "msg": response.text, "data": None})
+    else:
+        logger.error(f"❌ GET {url} failed with {response.status_code}")
+        logger.debug(response.text)
+        raise Exception(f"API GET failed with status code {response.status_code}: {response.text}")
+
+def delete_api(jwt_token: str, fragment: str, params: Optional[Dict[str, Any]] = None) -> WebServiceResponse:
+    """
+    Perform a DELETE request and parse the JSON response.
+    """
+    url = f"{API_URL}/{fragment}"
+    response = requests.delete(url, headers=get_headers(jwt_token, json=True), params=params)
+
+    if response.ok:
+        logger.info(f"✅ DELETE {url} successful!")
+        try:
+            data = response.json()
+            logger.debug(f"Response JSON: {data}")
+            return data
+        except ValueError:
+            return WebServiceResponse[str](**{"success": True, "msg": response.text, "data": None})
+    else:
+        logger.error(f"❌ GET {url} failed with {response.status_code}")
+        logger.debug(response.text)
+        raise Exception(f"API GET failed with status code {response.status_code}: {response.text}")
+
+
+def post_api(jwt_token: str, fragment: str, payload: Dict[str, Any]) -> WebServiceResponse:
+    """
+    Perform a POST request with a JSON body and parse JSON response.
+    """
+    url = f"{API_URL}/{fragment}"
+    response = requests.post(url, headers=get_headers(jwt_token, json=True), json=payload)
+
+    if response.ok:
+        logger.info(f"✅ JSON POST to {url} successful!")
+        try:
+            data = response.json()
+            logger.debug(f"Response JSON: {data}")
+            return data
+        except ValueError:
+            return WebServiceResponse[str](**{"success": True, "message": response.text, "data": None})
+    else:
+        logger.error(f"❌ JSON POST to {url} failed with {response.status_code}")
+        logger.debug(response.text)
+        raise Exception(f"API JSON POST failed with status code {response.status_code}: {response.text}")

kystdatahuset/auth.py

@@ -0,0 +1,30 @@
+import requests
+import json
+
+from kystdatahuset.models import AuthData, WebServiceResponse
+from kystdatahuset.logging import logger
+from .const import API_URL
+
+def login(username: str, password: str) -> WebServiceResponse[AuthData]:
+    reqUrl = f"{API_URL}/api/auth/login"
+
+    headersList = {
+        "User-Agent": "Kystdatahuset Python Library (https://your-client.com)",
+        "accept": "*/*",
+        "Content-Type": "application/json" 
+    }
+
+    payload = json.dumps({
+        "username": username,
+        "password": password
+    })
+
+    response = requests.request("POST", reqUrl, data=payload,  headers=headersList)
+
+    if response.status_code == 200:
+        logger.info("✅ Login successful!")
+        return WebServiceResponse[AuthData](**response.json()) 
+    else:
+        logger.error(f"❌ Login failed with status code {response.status_code}")
+        logger.debug(response.text)
+        raise Exception(f"Login failed with status code {response.status_code}: {response.text}")

kystdatahuset/const.py

@@ -0,0 +1 @@
+API_URL="https://kystdatahuset.no/ws"

kystdatahuset/file_storage.py

@@ -0,0 +1,54 @@
+from uuid import UUID
+from typing import Sequence, List
+from kystdatahuset.models import FileListing, WebServiceResponse
+from kystdatahuset.types import UploadFileType
+import os
+from kystdatahuset.api_client import post_api_formdata, get_api, delete_api
+
+def list(*, jwt_token: str, resource_uuid: UUID) -> List[FileListing]:
+    """
+    Placeholder for listing files in storage.
+    """
+    list_res = get_api(jwt_token, f"api/file-storage/list/{resource_uuid}")
+    file_listings = WebServiceResponse[List[FileListing]](**list_res)   
+    return file_listings.data
+
+def delete(* , jwt_token: str, file_uuid: UUID) -> bool:
+    """
+    Placeholder for deleting a file in storage.
+    """
+    delete_res = delete_api(jwt_token, f"api/file-storage/delete/{file_uuid}")
+    return delete_res.success
+
+def publish(
+    *,
+    jwt_token: str,
+    resource_uuid: UUID,
+    file_path: str,
+    title: str,
+    upload_file_type: UploadFileType,
+    description: str = "",
+    categories: Sequence[str] = "",
+    compressed: bool = False,
+) -> bool:
+    """
+    Upload a file and metadata to the Kystdatahuset API.
+    """
+
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    # Convert categories to multiple form fields (ASP.NET supports repeated keys)
+    # or as a JSON-like string, depending on the API’s binding expectations.
+    # The safe bet for ASP.NET [FromForm(Name="categories")] string[] is to repeat the key.
+    data = [
+        ("title", title),
+        ("description", description),
+        ("type", upload_file_type),
+        ("compressed", str(compressed).lower()),  # ASP.NET expects 'true'/'false'
+    ] + [("categories", c) for c in categories]
+
+    response = post_api_formdata(jwt_token, f"api/file-storage/publish/{resource_uuid}", data, file_path)
+    return response.success
+
+

kystdatahuset/logging.py

@@ -0,0 +1,13 @@
+import logging
+
+logger_name = __name__.split(".")[0]
+# Create a logger specific to your library
+logger = logging.getLogger(logger_name)
+logger.addHandler(logging.NullHandler())
+
+def enable_default_logging(level=logging.INFO):
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s")
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.setLevel(level)

kystdatahuset/models/AuthData.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+from datetime import datetime
+
+
+class AuthData(BaseModel):
+    JWT: str = Field(..., description="JSON Web Token for authentication")
+    Username: str = Field(..., description="User's email or username")
+    Timestamp: datetime = Field(..., description="Timestamp when the token was issued")
+
+

kystdatahuset/models/FileListing.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel, Field
+from typing import List
+from uuid import UUID
+
+
+class FileListing(BaseModel):
+    uuid: UUID = Field(..., description="Unique identifier for this file record")
+    title: str = Field(..., description="Title or display name of the uploaded file")
+    description: str = Field(..., description="Descriptive text about the file contents")
+    categories: List[str] = Field(..., description="List of category tags assigned to the file")
+    filetype: str = Field(..., description="Type or format of the uploaded file, e.g. csv, pdf")
+    compressed: bool = Field(..., description="True if the file was uploaded as compressed archive")
+    filename: str = Field(..., description="Server-side absolute file path")
+    origFilename: str = Field(..., description="Original filename on the client before upload")
+    resourceUuid: UUID = Field(..., description="UUID of the resource to which this file belongs")
+
+
+# # ✅ Example usage:
+# example_json = {
+#     'uuid': '69d47723-206c-4a89-8d67-654f23706e24',
+#     'title': 'Test Upload',
+#     'description': 'This is a test upload',
+#     'categories': ['test', 'upload'],
+#     'filetype': 'csv',
+#     'compressed': True,
+#     'filename': r'E:\storage\kystdathuset\catalog\2025\11\64\12\7f\64127fc2-2644-4ed9-b886-fecfb914c4b5\C_Users_runar.bergheim_Documents_Development_kystdatahuset-python-lib_test_data_content.txt',
+#     'origFilename': r'C:\\Users\\runar.bergheim\\Documents\\Development\\kystdatahuset-python-lib\\test_data\\content.txt',
+#     'resourceUuid': '64127fc2-2644-4ed9-b886-fecfb914c4b5'
+# }
+
+# listing = FileListing(**example_json)
+# print(listing.title)
+# print(listing.resourceUuid)

kystdatahuset/models/WebServiceResponse.py

@@ -0,0 +1,11 @@
+from pydantic import Field, BaseModel
+from typing import Generic, TypeVar, Optional
+
+T = TypeVar("T")
+
+class WebServiceResponse(BaseModel, Generic[T]):
+    success: bool = Field(..., description="Indicates if the request was successful")
+    msg: str = Field(..., description="Optional message from the API")
+    data: Optional[T] = Field(None, description="Container for typed response data")
+    time: Optional[float] = Field(None, description="Processing time in milliseconds or seconds")
+    executionTime: Optional[float] = Field(None, description="Processing time in milliseconds or seconds")

kystdatahuset/models/__init__.py

@@ -0,0 +1,3 @@
+from .AuthData import AuthData
+from .WebServiceResponse import WebServiceResponse
+from .FileListing import FileListing

kystdatahuset/types/PandasFrequency.py

@@ -0,0 +1,8 @@
+from typing import Literal, TypeAlias
+
+PandasFreqency: TypeAlias = Literal[
+    "B", "C", "D", "W", "W-MON", "W-TUE", "W-WED", "W-THU", "W-FRI", "W-SAT", "W-SUN",
+    "M", "MS", "Q", "QS", "A", "AS",
+    "H", "T", "min", "S", "L", "ms", "U", "us", "N",
+    "BH", "CBH", "BQS", "BA", "BAS", "BYS", "BY"
+]

kystdatahuset/types/UploadFileType.py

@@ -0,0 +1,18 @@
+from typing import Literal, TypeAlias
+
+UploadFileType: TypeAlias = Literal[
+    "csv",              # Comma Separated Variables
+    "shp-compressed",   # Compressed ESRI Shapefile
+    "fgdb-compressed",  # Compressed ESRI filegeodatabase
+    "json",             # JSON file
+    "geojson",          # GeoJSON file
+    "png",              # Portable Network Graphics image
+    "jpg",              # JPEG image
+    "pdf",              # Portable Document Format
+    "xlsx",             # Microsoft Excel spreadsheet
+    "xml",              # XML file
+    "docx",             # Microsoft Word document
+    "NetCDF",           # Network Common Data Form (NetCDF)
+    "tiff",             # Tagged Image File Format (*.tif)
+    "geotiff",          # Georeferenced Tagged Image File Format (*.tif)
+]

kystdatahuset/types/__init__.py

@@ -0,0 +1,2 @@
+from .PandasFrequency import PandasFreqency
+from .UploadFileType import UploadFileType

kystdatahuset/utils/__init__.py

@@ -0,0 +1,2 @@
+from ._date_range import date_range
+from ._slice_polygon_to_grid import slice_polygon_to_grid

kystdatahuset/utils/_date_range.py

@@ -0,0 +1,15 @@
+from typing import List
+import pandas as pd 
+from datetime import datetime
+from kystdatahuset.types import PandasFreqency
+from more_itertools import pairwise
+
+def date_range(start_date: datetime, end_date: datetime, freq: PandasFreqency = "D") -> List[datetime]:
+    """
+    Generate a list of dates from start_date to end_date, inclusive.
+    """
+    if start_date > end_date:
+        raise ValueError("start_date must be less than or equal to end_date")
+    
+    dates = pd.date_range(start=start_date, end=end_date, freq=freq)
+    return pairwise([dt.to_pydatetime() for dt in dates])    

kystdatahuset/utils/_slice_polygon_to_grid.py

@@ -0,0 +1,48 @@
+from shapely.geometry import Polygon, box
+from shapely.ops import unary_union
+import numpy as np
+from typing import List, Tuple
+from shapely import wkt
+
+def slice_polygon_to_grid(
+    wkt_polygon: str,
+    grid_size: float,
+    bbox: Tuple[float, float, float, float] = None
+) -> List[str]:
+    """
+    Slice a large polygon into smaller pieces that fit a regular grid.
+
+    Args:
+        wkt_polygon (str): The well-known text representation of the polygon to be sliced.
+        grid_size (float): The grid cell size (in same units as polygon coordinates).
+        bbox (tuple, optional): (minx, miny, maxx, maxy) to constrain the grid.
+            If not provided, the polygon's bounding box is used.
+
+    Returns:
+        List[str]: List of wkt polygon strings  (each is the intersection of the polygon and one grid cell).
+    """
+    
+    polygon = wkt.loads(wkt_polygon)
+    
+    if bbox is None:
+        minx, miny, maxx, maxy = polygon.bounds
+    else:
+        minx, miny, maxx, maxy = bbox
+
+    # Create grid coordinates
+    x_coords = np.arange(minx, maxx, grid_size)
+    y_coords = np.arange(miny, maxy, grid_size)
+
+    pieces = []
+    for x in x_coords:
+        for y in y_coords:
+            cell = box(x, y, x + grid_size, y + grid_size)
+            intersection = polygon.intersection(cell)
+            if not intersection.is_empty:
+                # Handle MultiPolygons (split into individual polygons)
+                if intersection.geom_type == "Polygon":
+                    pieces.append(intersection)
+                elif intersection.geom_type == "MultiPolygon":
+                    pieces.extend(intersection.geoms)
+
+    return [wkt.dumps(p) for p in pieces]

kystdatahuset/voyage.py

@@ -0,0 +1,45 @@
+from typing import List, Dict
+from requests_cache import datetime
+from kystdatahuset.api_client import post_api
+from kystdatahuset.types import PandasFrequency
+from kystdatahuset.utils import date_range
+
+def get_voyages_for_ships_by_mmsi(auth_jwt: str, mmsi_ids: List[int], start_date: datetime, end_date: datetime, freq: PandasFrequency = "MS") -> List[Dict]:
+    """Get voyagen data for ships identified by MMSI ids
+
+    Args:
+        auth_jwt (str): A valid JWT retrieved through an authentication call to the API
+        mmsi_ids (List[int]): A list of one or more MMSIs
+        start_date (datetime): A start date
+        end_date (datetime): An end date
+        freq (PandasFrequency, optional): An optional frequency that the request will be split into. Defaults to "MS".
+
+    Raises:
+        Exception: If the API call fails or returns an error.
+
+    Returns:
+        List[Dict]: List of voyages
+    """
+    responses = []
+    
+    date_ranges = date_range(start_date, end_date, freq)
+    for pair in date_ranges:
+        print(pair)  # Debug print to verify date ranges    
+        
+        response = post_api(
+            jwt_token=auth_jwt,
+            fragment="api/voyage/for-ships/by-mmsi",
+            payload={
+                "mmsiIds": mmsi_ids,
+                "startTime": start_date.isoformat(),
+                "endTime": end_date.isoformat()
+            },
+        )
+        
+        if (response is None) or (not response["success"]):
+            raise Exception(f"Failed to get voyages for ships by MMSI: {response['msg'] if response else 'No response'}")
+        else:
+            responses.extend(response["data"])
+
+    return responses
+

kystdatahuset_python_lib-0.9.5.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: kystdatahuset-python-lib
+Version: 0.9.5
+Summary: A python library for accessing and querying data from Kystdatahuset
+Author-email: Kystdatahuset developer team <support@kystdatahuset.no>, "(Stein) Runar Bergheim" <runar.bergheim@avinet.no>, Sigve Bergh <sigve.bergh@kystverket.no>, Hermann Klaus Kurt von Lupfert <hermann.lupfert@kystverket.no>
+Maintainer-email: Kystdatahuset developer team <support@kystdatahuset.no>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Kystverket/kystdatahuset-python-lib
+Project-URL: Repository, https://github.com/Kystverket/kystdatahuset-python-lib
+Project-URL: Issues, https://github.com/Kystverket/kystdatahuset-python-lib/issues
+Keywords: spatial,analytics,visualization,geodata
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: requests>=2.28
+Requires-Dist: shapely>=2.0
+Requires-Dist: tqdm>=4.65
+Dynamic: license-file
+
+# Kystdatahuset Python Library
+
+`kystdatahuset-python-lib` — Python SDK companion for the Kystdatahuset API
+
+`kystdatahuset-python-lib` is the official Python client for accessing the **Kystdatahuset API**, a unified data and knowledge platform for coastal and maritime spatial analytics. 
+
+It provides a clean, Pythonic, and strongly typed interface for querying datasets, managing authentication, and performing efficient data access.
+
+---
+
+## ✨ Features
+
+### 🚀 Easy Installation  
+Install directly from PyPI:
+
+```bash
+pip install kystdatahuset-python-lib
+```
+
+Supports Python **3.9+** on Linux, macOS, and Windows.
+
+---
+
+### 🔐 Simple Authentication  
+The client offers:
+
+- API key authentication  
+- Support for headless servers and notebooks
+
+Example:
+
+```python
+from kystdatahuset.auth import login
+import os
+
+    login_response = login("username", "password")
+    jwt = auth_res.data.JWT
+    voyages = get_voyages_for_ships_by_mmsi(
+        auth_jwt=jwt,
+        mmsi_ids=[258090000, 259028000],
+        start_date=datetime(2024,1,1),
+        end_date=datetime(2024,5,1),
+    )
+
+```
+---
+
+## 🌍 Efficient & “Social” Data Access
+
+Instead of fetching massive multi-GB extracts, the library is designed for **smart, cooperative usage patterns**, where users share infrastructure responsibly:
+
+### ✅ Time Window Batching  
+Fetch long time periods in small, safe slices, python/Pandas "periods"
+
+
+### ✅ Geographic Slicing  
+Request only the needed spatial extent by WKT filters
+
+---
+
+## 🧱 Library Structure
+
+```
++---kystdatahuset
+|   |   ais.py
+|   |   api_client.py
+|   |   auth.py
+|   |   const.py
+|   |   file_storage.py
+|   |   logging.py
+|   |   voyage.py
+|   |   __init__.py
+|   |
+|   +---models
+|   |   |   AuthData.py
+|   |   |   FileListing.py
+|   |   |   WebServiceResponse.py
+|   |   |   __init__.py
+|   |   |
+|   |
+|   +---types
+|   |   |   PandasFrequency.py
+|   |   |   UploadFileType.py
+|   |   |   __init__.py
+|   |   |
+|   |
+|   +---utils
+|   |   |   _date_range.py
+|   |   |   __init__.py
+```
+
+---
+
+## 📦 Development & Distribution
+
+`kystdatahuset-py` uses standard packaging:
+
+- `pyproject.toml` + `PEP 621` metadata  
+- versioning via Semantic Versioning  
+- full type hints (mypy-friendly)  
+- GitHub Actions for automated testing & publishing   
+
+---
+
+## 🧠 Typical Use Cases
+
+- Query live AIS vessel data efficiently  
+- Retrieve spatial datasets in bounded windows  
+- Build dashboards, decision-support tools, or AI/ML pipelines  
+- Avoid oversized extracts by using time/space batching helpers  
+
+---
+
+## 📄 License
+
+Open source under the **MIT License**.
+

kystdatahuset_python_lib-0.9.5.dist-info/RECORD

@@ -0,0 +1,24 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kystdatahuset/__init__.py,sha256=UvB3IZAWAs7vV6H9dpZvZPryrSNIyF5_bowVS4_YGFA,23
+kystdatahuset/ais.py,sha256=oKdZKYpPhTJfsomtfSKkAKvMS3DNE8bGwxkeSZPIf-w,906
+kystdatahuset/api_client.py,sha256=7JwlOjOQc8KUf_mbgikfEFF6I-e0ieoQW1z7rJJUT5Y,4216
+kystdatahuset/auth.py,sha256=i4RykZNItbKDr3MmaMzTOE0KuJddaRVayOPp5RpmGH4,1029
+kystdatahuset/const.py,sha256=joWTuKfhvJaCnbRNzt3mzx10QivShtD80ehDaREtTUY,37
+kystdatahuset/file_storage.py,sha256=TIi9MPEnY9KoYVD4ppva5F-sRizGRnvtthHc8BbRcxc,1907
+kystdatahuset/logging.py,sha256=OLd_HsQviwZtuKktTZ8xgSwen4PvMUswO8ERCRFnWc4,456
+kystdatahuset/voyage.py,sha256=71WdAyjbTZ6zSXuPTK2s7CtTpUZJbNBWdtznxeor2s0,1711
+kystdatahuset/models/AuthData.py,sha256=xGCEGH3IT1LOsgDLr9Mn7ovCfsBRzCGL-RjQPfCfsMg,343
+kystdatahuset/models/FileListing.py,sha256=fTji8MLS9cwUZNrBsYYhydmrbjHJv5uBNp9Yg5ShYT4,1724
+kystdatahuset/models/WebServiceResponse.py,sha256=BvPQmpXgrDxRLtm4KfMUguEM2UFWHtGfrs4pV0taXJ8,608
+kystdatahuset/models/__init__.py,sha256=XEK05NfbaW8KD14KmlFCCf8rs3FfWpsd8j93tWYIin0,122
+kystdatahuset/types/PandasFrequency.py,sha256=WAa2YRBX84i_QOvsmqLeUXO8dCEbVNT3PMbEsIAHQ8s,312
+kystdatahuset/types/UploadFileType.py,sha256=j3Jmu-HcUoYVxLxLa8UvKAIp_hLUjEkpL6UAD9QdVQI,808
+kystdatahuset/types/__init__.py,sha256=L53ckYQ0Jo-czN5UuFUJbgvFYJJ6mfTNxPrg4ooXNf8,87
+kystdatahuset/utils/__init__.py,sha256=oDC86K-h5VDRtXgCNjuGck1ffbH7AVfI2hH1bzj1Iqk,94
+kystdatahuset/utils/_date_range.py,sha256=aacQixPn0R8Os9hatf29GN5WgIJAVAHB7KqVQaEbnLI,607
+kystdatahuset/utils/_slice_polygon_to_grid.py,sha256=2xH3RBLICcAFz5jtROkJ1xEr5umTFxEkNl7-Ycr02cU,1729
+kystdatahuset_python_lib-0.9.5.dist-info/licenses/LICENSE,sha256=x8ID0mDBvvKlF9ZZhYRj2-fSr20ZhXEdCFA4ewrEMxw,1086
+kystdatahuset_python_lib-0.9.5.dist-info/METADATA,sha256=7o0gPTeAXc4-m8em0bis8yQUOGSMYnc_WbOYIgC6X3w,4055
+kystdatahuset_python_lib-0.9.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kystdatahuset_python_lib-0.9.5.dist-info/top_level.txt,sha256=vMgxr4VS5IiCspq8gKnP4Ceie8VNiPqQciArk4-0YmU,23
+kystdatahuset_python_lib-0.9.5.dist-info/RECORD,,

kystdatahuset_python_lib-0.9.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kystdatahuset_python_lib-0.9.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kystverket
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kystdatahuset_python_lib-0.9.5.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+kystdatahuset