datagovmy-python-sdk 1.0.1__tar.gz

datagovmy_python_sdk-1.0.1/.claude/agents/security-code-reviewer.md

@@ -0,0 +1,123 @@
+---
+name: security-code-reviewer
+description: "Proactively use this agent when code has been written or modified and needs to be reviewed for security vulnerabilities, coding best practices, and potential issues. This includes after writing new functions, refactoring existing code, or implementing features that handle user input, authentication, data storage, or network communication.\\n\\nExamples:\\n\\n- User: \"Implement a login endpoint that accepts username and password\"\\n  Assistant: \"Here is the login endpoint implementation:\"\\n  <function call to write the code>\\n  Since security-sensitive code was written (authentication), use the Agent tool to launch the security-code-reviewer agent to review the code for vulnerabilities.\\n  Assistant: \"Now let me use the security-code-reviewer agent to review this code for security issues.\"\\n\\n- User: \"Add a function to query the database based on user input\"\\n  Assistant: \"Here is the database query function:\"\\n  <function call to write the code>\\n  Since code handling user input and database queries was written, use the Agent tool to launch the security-code-reviewer agent to check for SQL injection and other vulnerabilities.\\n  Assistant: \"Let me run the security-code-reviewer agent to ensure this is safe from injection attacks.\"\\n\\n- User: \"Can you review the changes I just made?\"\\n  Assistant: \"I'll use the security-code-reviewer agent to review your recent changes.\"\\n  Since the user explicitly requested a review, use the Agent tool to launch the security-code-reviewer agent."
+tools: Bash, Glob, Grep, Read, WebFetch, WebSearch, Skill, TaskCreate, TaskGet, TaskUpdate, TaskList, EnterWorktree, ToolSearch
+model: sonnet
+color: red
+memory: project
+---
+
+You are an elite security-focused code reviewer with deep expertise in application security, secure coding practices, and vulnerability assessment. You have extensive knowledge of OWASP Top 10, CWE classifications, and language-specific security pitfalls. You approach every review with the mindset of both a defensive developer and an offensive security researcher.
+
+## Core Responsibilities
+
+1. **Security Vulnerability Detection**: Identify vulnerabilities including but not limited to:
+   - Injection flaws (SQL, NoSQL, OS command, LDAP, XSS)
+   - Broken authentication and session management
+   - Sensitive data exposure (hardcoded secrets, insufficient encryption, logging PII)
+   - Insecure deserialization
+   - Broken access control and privilege escalation paths
+   - Server-side request forgery (SSRF)
+   - Path traversal and file inclusion
+   - Race conditions and TOCTOU bugs
+   - Unsafe use of cryptographic primitives
+   - Dependency vulnerabilities and supply chain risks
+
+2. **Coding Best Practices**: Evaluate code for:
+   - Input validation and sanitization completeness
+   - Proper error handling (no information leakage in errors)
+   - Principle of least privilege adherence
+   - Defense in depth implementation
+   - Secure defaults
+   - DRY, SOLID, and clean code principles where they intersect with security
+   - Proper resource management (file handles, connections, memory)
+   - Type safety and null safety
+
+3. **Code Quality with Security Implications**: Flag:
+   - Overly complex logic that obscures security-relevant behavior
+   - Missing or inadequate logging for security events
+   - Insufficient or misleading comments on security-critical sections
+   - Inconsistent error handling patterns
+
+## Review Process
+
+When reviewing code:
+
+1. **Scope**: Focus on recently written or modified code. Read the relevant files and understand the context of changes.
+2. **Analyze data flow**: Trace how user-controlled input flows through the code. Identify trust boundaries.
+3. **Check each function/method**: Evaluate inputs, outputs, side effects, and error paths.
+4. **Assess dependencies**: Note any use of external libraries and whether they are used securely.
+5. **Consider the deployment context**: Think about how the code will run and what attack surface it exposes.
+
+## Output Format
+
+Structure your review as follows:
+
+### Summary
+A brief overall assessment (1-3 sentences) with a severity rating: ✅ Clean, ⚠️ Minor Issues, 🔶 Moderate Issues, 🔴 Critical Issues.
+
+### Findings
+For each issue found, provide:
+- **Severity**: Critical / High / Medium / Low / Informational
+- **Category**: (e.g., Injection, Auth, Data Exposure, Best Practice)
+- **Location**: File and line reference
+- **Description**: Clear explanation of the issue
+- **Impact**: What could go wrong if exploited or left unaddressed
+- **Recommendation**: Specific fix with code example when helpful
+
+List findings in order of severity (critical first).
+
+### Positive Observations
+Briefly note any security best practices already well-implemented — this reinforces good habits.
+
+## Guidelines
+
+- Be precise and actionable. Avoid vague advice like "improve security." Always say exactly what to change and why.
+- Distinguish between confirmed vulnerabilities and potential concerns that depend on context.
+- If you lack sufficient context to determine severity, state your assumptions clearly.
+- Do not overwhelm with noise — prioritize findings that have real security impact.
+- When a pattern appears multiple times, note it once and indicate all affected locations.
+- If the code looks secure, say so confidently rather than inventing issues.
+
+**Update your agent memory** as you discover security patterns, recurring vulnerabilities, coding conventions, authentication/authorization patterns, and dependency usage in this codebase. This builds up institutional knowledge across conversations. Write concise notes about what you found and where.
+
+Examples of what to record:
+- Common input validation patterns used in the project
+- Authentication and authorization mechanisms and their locations
+- Cryptographic library usage and configuration patterns
+- Known areas of technical debt with security implications
+- Project-specific security conventions or middleware
+
+# Persistent Agent Memory
+
+You have a persistent Persistent Agent Memory directory at `/Users/chriskhoo/Documents/Code/bbprojects/std-pipeline/.claude/agent-memory/security-code-reviewer/`. Its contents persist across conversations.
+
+As you work, consult your memory files to build on previous experience. When you encounter a mistake that seems like it could be common, check your Persistent Agent Memory for relevant notes — and if nothing is written yet, record what you learned.
+
+Guidelines:
+- `MEMORY.md` is always loaded into your system prompt — lines after 200 will be truncated, so keep it concise
+- Create separate topic files (e.g., `debugging.md`, `patterns.md`) for detailed notes and link to them from MEMORY.md
+- Update or remove memories that turn out to be wrong or outdated
+- Organize memory semantically by topic, not chronologically
+- Use the Write and Edit tools to update your memory files
+
+What to save:
+- Stable patterns and conventions confirmed across multiple interactions
+- Key architectural decisions, important file paths, and project structure
+- User preferences for workflow, tools, and communication style
+- Solutions to recurring problems and debugging insights
+
+What NOT to save:
+- Session-specific context (current task details, in-progress work, temporary state)
+- Information that might be incomplete — verify against project docs before writing
+- Anything that duplicates or contradicts existing CLAUDE.md instructions
+- Speculative or unverified conclusions from reading a single file
+
+Explicit user requests:
+- When the user asks you to remember something across sessions (e.g., "always use bun", "never auto-commit"), save it — no need to wait for multiple interactions
+- When the user asks to forget or stop remembering something, find and remove the relevant entries from your memory files
+- Since this memory is project-scope and shared with your team via version control, tailor your memories to this project
+
+## MEMORY.md
+
+Your MEMORY.md is currently empty. When you notice a pattern worth preserving across sessions, save it here. Anything in MEMORY.md will be included in your system prompt next time.

datagovmy_python_sdk-1.0.1/.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: CI
+
+on:
+  push:
+    tags: ["v*"]
+  pull_request:
+    branches: [main]
+    types: [opened, synchronize, reopened, ready_for_review]
+
+jobs:
+  lint:
+    name: PR Linting
+    runs-on: ubuntu-latest
+    steps:
+      - name: Run Python quality checks
+        uses: thekhoo/github-actions-shared/.github/actions/python-linting@main
+        with:
+          python-version: 3.13
+          directories: datagovmy/ tests/
+          use-ruff: true
+          use-pyrefly: true
+
+  test:
+    name: PR Unit Tests
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.13", "3.14"]
+    steps:
+      - name: Run Python quality checks
+        uses: thekhoo/github-actions-shared/.github/actions/python-pytest@main
+        with:
+          python-version: ${{ matrix.python-version }}
+          test-directories: tests/

datagovmy_python_sdk-1.0.1/.github/workflows/release.yml

@@ -0,0 +1,48 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  ci:
+    name: CI
+    uses: thekhoo/github-actions-shared/.github/workflows/python-ci.yml@main
+    with:
+      linting-python-version: "3.13"
+      pytest-python-versions: '["3.13", "3.14"]'
+      lint-directories: "datagovmy/ tests/"
+      use-ruff: true
+      use-pyrefly: true
+      test-directories: "tests/"
+
+  release:
+    name: Semantic Release
+    needs: ci
+    runs-on: ubuntu-latest
+    environment: production
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Run semantic release
+        id: release
+        uses: thekhoo/github-actions-shared/.github/actions/python-semantic-release@main
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          python-version: "3.13"
+
+      - name: Publish to PyPI
+        if: steps.release.outputs.released == 'true'
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Publish GitHub Release
+        if: steps.release.outputs.released == 'true'
+        uses: thekhoo/github-actions-shared/.github/actions/github-publish-release@main
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          tag: ${{ steps.release.outputs.tag }}

datagovmy_python_sdk-1.0.1/.gitignore

@@ -0,0 +1,14 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+env/
+
+# Environment variables
+.env

datagovmy_python_sdk-1.0.1/.python-version

@@ -0,0 +1 @@
+3.13

datagovmy_python_sdk-1.0.1/.vscode/settings.json

@@ -0,0 +1,12 @@
+{
+  "task.allowAutomaticTasks": "on",
+  "editor.formatOnSave": true,
+  "[python]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.codeActionsOnSave": {
+      "source.fixAll.ruff": "explicit",
+      "source.organizeImports.ruff": "explicit"
+    }
+  }
+}

datagovmy_python_sdk-1.0.1/CHANGELOG.md

@@ -0,0 +1,15 @@
+# CHANGELOG
+
+<!-- version list -->
+
+## v1.0.1 (2026-03-29)
+
+### Bug Fixes
+
+- Add environment to release
+  ([`fd8ec63`](https://github.com/thekhoo/datagovmy-python-sdk/commit/fd8ec638979021ab677a66b3241b7cc34d7a19eb))
+
+
+## v1.0.0 (2026-03-29)
+
+- Initial Release

datagovmy_python_sdk-1.0.1/CLAUDE.md

@@ -0,0 +1,103 @@
+# CLAUDE.md — datagovmy-python-sdk
+
+## Project Overview
+
+Unofficial Python SDK for accessing open data from Malaysia's [data.gov.my](https://data.gov.my) platform via their [Open API](https://developer.data.gov.my/).
+
+**Package name:** `mydata` (importable module in `mydata/`)
+**Python:** >=3.13 (managed via `.python-version`)
+**Build system:** Standard `pyproject.toml` (no build backend specified yet)
+
+## API Reference (data.gov.my)
+
+Base URL: `https://api.data.gov.my`
+
+## Always do this
+
+- When implementing a feature, always come up with a plan before making any code changes
+- If requirements are not clear, always ask for clarity - never assume
+- Always use TDD to implement new features
+- After writing executable code, run the unit tests and linters and ensure all of them pass
+- Always commit in small chunks. Unit tests and linters must pass before committing
+- Be clear and concise with your code. I fthere are hidden implications, leave comments explaining why
+- Make sure logs are written at difference code checkpoints. Do not be too verbose
+- Use existing utility functions instead of re-implementing. Helper functions should be reusable in an appropriately named module
+
+## Never do this
+
+- Change main code when there are no unit tests that capture the functionality. add unit tests before making any changes
+- Do not hardcode secrets or ARNs within the code. Any secrets should be taken from SSM
+- Do not expose any tenanted information within the log messages
+
+## Coding Conventions
+
+### Environment
+
+- All environment variable access should be done using helper functions in mydata/service/environment.py and not os.environ directly in the code.
+
+### Endpoints
+
+| Endpoint                                       | Returns  | Description                                   |
+| ---------------------------------------------- | -------- | --------------------------------------------- |
+| `GET /data-catalogue?id=<id>`                  | JSON     | National data catalogue datasets              |
+| `GET /opendosm?id=<id>`                        | JSON     | Dept of Statistics (DOSM) datasets            |
+| `GET /weather/forecast`                        | JSON     | 7-day weather forecast                        |
+| `GET /weather/warning`                         | JSON     | Weather warnings                              |
+| `GET /weather/warning/earthquake`              | JSON     | Earthquake warnings                           |
+| `GET /gtfs-static/<agency>`                    | ZIP      | GTFS static feeds (ktmb, prasarana, mybas-\*) |
+| `GET /gtfs-realtime/vehicle-position/<agency>` | Protobuf | Real-time vehicle positions                   |
+
+### Authentication
+
+- **Optional.** API works without a token (4 req/min).
+- With token (10 req/min): `Authorization: Token <TOKEN>`
+
+### Query Parameters (JSON endpoints)
+
+| Param                               | Usage                                                      |
+| ----------------------------------- | ---------------------------------------------------------- |
+| `id`                                | Dataset identifier (required for data-catalogue/opendosm)  |
+| `limit`                             | Max records to return                                      |
+| `filter` / `ifilter`                | Exact match (case-sensitive / insensitive): `value@column` |
+| `contains` / `icontains`            | Partial match: `value@column`                              |
+| `range`                             | Numeric range: `column[begin:end]`                         |
+| `sort`                              | Sort: `column,-column2` (dash = descending)                |
+| `include` / `exclude`               | Select/omit columns                                        |
+| `date_start` / `date_end`           | Date filter (`YYYY-MM-DD`)                                 |
+| `timestamp_start` / `timestamp_end` | Timestamp filter (`YYYY-MM-DD HH:MM:SS`)                   |
+| `meta=true`                         | Include metadata wrapper in response                       |
+
+Multiple filters: comma-separated. Nested fields: double underscores (e.g. `location__location_name`).
+
+### Response Format
+
+- Success: JSON array of records (or `{"meta": {}, "data": []}` with `meta=true`)
+- Error: `{"status": <int>, "errors": [...]}`
+- Status codes: 200, 400, 404, 429, 500
+
+### Rate Limits
+
+- Without token: **4 requests/minute**
+- With token: **10 requests/minute**
+- Exceeding returns HTTP 429
+
+## Development Guidelines
+
+- All endpoints are **read-only GET** requests — the SDK only needs HTTP GET support.
+- Use `httpx` or `requests` as the HTTP client (add to `pyproject.toml` dependencies).
+- The SDK should support both sync and async usage patterns.
+- Handle rate limiting gracefully (retry with backoff on 429).
+- Dataset IDs can be discovered at https://data.gov.my/data-catalogue or https://open.dosm.gov.my/data-catalogue.
+
+## Commands
+
+```bash
+# Run the project
+uv run main.py
+
+# Run tests (once added)
+uv run pytest
+
+# Install dependencies
+uv sync
+```

datagovmy_python_sdk-1.0.1/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: datagovmy-python-sdk
+Version: 1.0.1
+Summary: Add your description here
+Requires-Python: >=3.13
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+# Data.gov.my Python SDK
+
+Unofficial SDK for accessing open source data on https://data.gov.my.
+
+## Installation
+
+```bash
+pip install mydata
+```
+
+## Quick Start
+
+```python
+from datagovmy import DataGovMyClient
+
+client = DataGovMyClient()
+
+# Fetch a dataset from the national data catalogue
+data = client.data_catalogue.get_dataset_as_json(id="population_malaysia")
+
+# Fetch with filters
+data = client.data_catalogue.get_dataset_as_json(
+    id="population_malaysia",
+    filter="Selangor@location",
+    sort="-year",
+    limit=10
+)
+
+# Fetch DOSM data
+data = client.opendosm.get_dataset_as_json(id="cpi_2d_category")
+```
+
+## Documentation
+
+For detailed usage examples including all supported query filters (filtering, sorting, pagination, date ranges, column selection, and more), see the [Usage Guide](docs/usage.md).
+
+## API Reference
+
+This SDK wraps the [data.gov.my Open API](https://developer.data.gov.my/). Dataset IDs can be discovered at:
+
+- [data.gov.my Data Catalogue](https://data.gov.my/data-catalogue)
+- [OpenDOSM Data Catalogue](https://open.dosm.gov.my/data-catalogue)
+
+## Rate Limits
+
+- Without API key: **4 requests/minute**
+- With API key: **10 requests/minute**
+
+```python
+client = DataGovMyClient(api_key="your-api-key")
+```
+
+## License
+
+MIT

datagovmy_python_sdk-1.0.1/README.md

@@ -0,0 +1,55 @@
+# Data.gov.my Python SDK
+
+Unofficial SDK for accessing open source data on https://data.gov.my.
+
+## Installation
+
+```bash
+pip install mydata
+```
+
+## Quick Start
+
+```python
+from datagovmy import DataGovMyClient
+
+client = DataGovMyClient()
+
+# Fetch a dataset from the national data catalogue
+data = client.data_catalogue.get_dataset_as_json(id="population_malaysia")
+
+# Fetch with filters
+data = client.data_catalogue.get_dataset_as_json(
+    id="population_malaysia",
+    filter="Selangor@location",
+    sort="-year",
+    limit=10
+)
+
+# Fetch DOSM data
+data = client.opendosm.get_dataset_as_json(id="cpi_2d_category")
+```
+
+## Documentation
+
+For detailed usage examples including all supported query filters (filtering, sorting, pagination, date ranges, column selection, and more), see the [Usage Guide](docs/usage.md).
+
+## API Reference
+
+This SDK wraps the [data.gov.my Open API](https://developer.data.gov.my/). Dataset IDs can be discovered at:
+
+- [data.gov.my Data Catalogue](https://data.gov.my/data-catalogue)
+- [OpenDOSM Data Catalogue](https://open.dosm.gov.my/data-catalogue)
+
+## Rate Limits
+
+- Without API key: **4 requests/minute**
+- With API key: **10 requests/minute**
+
+```python
+client = DataGovMyClient(api_key="your-api-key")
+```
+
+## License
+
+MIT

datagovmy_python_sdk-1.0.1/datagovmy/__init__.py

@@ -0,0 +1,3 @@
+from datagovmy.datagovmy import DataGovMyClient
+
+__all__ = ["DataGovMyClient"]

datagovmy_python_sdk-1.0.1/datagovmy/core/api.py

@@ -0,0 +1,76 @@
+import logging
+from typing import Any, Optional, cast
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+logger = logging.getLogger(__name__)
+
+
+class BaseAPIClient:
+    """Generic API client with configurable retry support.
+
+    Args:
+        base_url: Base URL for all requests (e.g. "https://api.example.com").
+        headers: Default headers sent with every request.
+        retry_strategy: A ``urllib3.util.retry.Retry`` instance that controls
+            which status codes trigger retries, how many times, and the backoff.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        headers: Optional[dict[str, str]] = None,
+        retry_strategy: Optional[Retry] = None,
+    ):
+        self.base_url = base_url
+        self.session = requests.Session()
+        if headers:
+            self.session.headers.update(headers)
+        if retry_strategy:
+            adapter = HTTPAdapter(max_retries=cast(Any, retry_strategy))
+            self.session.mount("http://", adapter)
+            self.session.mount("https://", adapter)
+
+    def _build_url(self, path: str) -> str:
+        return f"{self.base_url}{path}"
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> requests.Response:
+        url = self._build_url(path)
+        logger.debug("Requesting %s %s", method, url)
+        response = self.session.request(method, url, **kwargs)
+        response.raise_for_status()
+        return response
+
+    def get(
+        self,
+        path: str,
+        params: Optional[dict[str, Any]] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> requests.Response:
+        return self._request("GET", path, params=params, headers=headers)
+
+    def post(
+        self,
+        path: str,
+        json: Optional[Any] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> requests.Response:
+        return self._request("POST", path, json=json, headers=headers)
+
+    def put(
+        self,
+        path: str,
+        json: Optional[Any] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> requests.Response:
+        return self._request("PUT", path, json=json, headers=headers)
+
+    def delete(
+        self,
+        path: str,
+        params: Optional[dict[str, Any]] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> requests.Response:
+        return self._request("DELETE", path, params=params, headers=headers)

datagovmy_python_sdk-1.0.1/datagovmy/datagovmy.py

@@ -0,0 +1,22 @@
+from typing import Optional
+
+from datagovmy.service import DataCatalogueClient, OpenDOSMClient
+
+
+class DataGovMyClient:
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key
+        self._data_catalogue: Optional[DataCatalogueClient] = None
+        self._opendosm: Optional[OpenDOSMClient] = None
+
+    @property
+    def data_catalogue(self) -> DataCatalogueClient:
+        if self._data_catalogue is None:
+            self._data_catalogue = DataCatalogueClient(api_key=self.api_key)
+        return self._data_catalogue
+
+    @property
+    def opendosm(self) -> OpenDOSMClient:
+        if self._opendosm is None:
+            self._opendosm = OpenDOSMClient(api_key=self.api_key)
+        return self._opendosm

datagovmy_python_sdk-1.0.1/datagovmy/service/__init__.py

@@ -0,0 +1,4 @@
+from datagovmy.service.data_catalogue import DataCatalogueClient
+from datagovmy.service.open_dosm import OpenDOSMClient
+
+__all__ = ["DataCatalogueClient", "OpenDOSMClient"]

datagovmy_python_sdk-1.0.1/datagovmy/service/data_catalogue.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from datagovmy.core.api import BaseAPIClient
+from datagovmy.service.environment import get_base_url
+
+
+class DataCatalogueClient(BaseAPIClient):
+    ENDPOINT = "/data-catalogue"
+
+    def __init__(self, api_key: Optional[str] = None):
+        super().__init__(base_url=get_base_url())
+        self.api_key = api_key
+
+    def get_dataset_as_json(self, id: str, **kwargs):
+        # kwargs can be used to add additional query parameters for filtering
+        # reference: https://developer.data.gov.my/request-query
+        endpoint = f"{self.ENDPOINT}?id={id}"
+        filters = "&".join(f"{k}={v}" for k, v in kwargs.items())
+
+        if filters:
+            endpoint += f"&{filters}"
+
+        return self.get(endpoint).json()

datagovmy_python_sdk-1.0.1/datagovmy/service/environment.py

@@ -0,0 +1,2 @@
+def get_base_url():
+    return "https://api.data.gov.my"

datagovmy_python_sdk-1.0.1/datagovmy/service/exceptions.py

@@ -0,0 +1,6 @@
+class FatalException(Exception):
+    pass
+
+
+class UnknownServiceException(FatalException):
+    pass

datagovmy_python_sdk-1.0.1/datagovmy/service/open_dosm.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+from datagovmy.core.api import BaseAPIClient
+from datagovmy.service.environment import get_base_url
+
+
+class OpenDOSMClient(BaseAPIClient):
+    ENDPOINT = "/opendosm"
+
+    def __init__(self, api_key: Optional[str] = None):
+        super().__init__(base_url=get_base_url())
+        self.api_key = api_key
+
+    def get_dataset_as_json(self, id: str, **kwargs):
+        # kwargs can be used to add additional query parameters for filtering
+        # reference: https://developer.data.gov.my/request-query
+        endpoint = f"{self.ENDPOINT}?id={id}"
+        filters = "&".join(f"{k}={v}" for k, v in kwargs.items())
+
+        if filters:
+            endpoint += f"&{filters}"
+
+        return self.get(endpoint).json()