dailydotsnek 1.0.0__tar.gz

dailydotsnek-1.0.0/.gitignore

@@ -0,0 +1 @@
+test.txt

dailydotsnek-1.0.0/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Changelog
+
+See docs/changelog.md for the full changelog.
+
+## [1.0.0] - 2026-10-13
+- Initial release

dailydotsnek-1.0.0/CONTRIBUTING.md

@@ -0,0 +1 @@
+See docs/contributing.md for contribution guidelines and local development instructions.

dailydotsnek-1.0.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.5
+Name: dailydotsnek
+Version: 1.0.0
+Summary: Python SDK for Daily.dev api
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# dailydotsnek
+
+A lightweight, well-documented Python SDK for the daily.dev public API.
+
+Features
+- Clean, minimal API client interfaces
+- Environment- or manual-token authentication helpers
+- Full method coverage for feeds, posts, bookmarks, profile, and search
+
+Installation
+
+Install from PyPI when the package is published:
+
+```bash
+pip install dailydotsnek
+```
+
+(For local development):
+
+```bash
+pip install -e .
+```
+
+Quickstart
+
+```python
+from snek.tokenSys import AutoApiToken, ManualApiToken
+from snek.snekSDK import SnekSDK
+
+# AutoApiToken reads the DAILY_DEV_KEY env var (via python-dotenv)
+token = AutoApiToken()
+# or
+# token = ManualApiToken("your_api_key_here")
+
+client = SnekSDK(token)
+
+posts = client.getPopularFeed()
+print(posts)
+```
+
+Documentation
+
+A full, polished documentation site is included under `docs/` and configured with MkDocs.
+
+Building the package (locally)
+
+- Build a wheel with hatch (project uses hatchling):
+
+```bash
+python -m pip install -U hatch
+hatch build
+```
+
+- The built artifacts will be in `dist/`.
+
+Publishing (prepare-only):
+
+This repository has been prepared for PyPI publishing. To publish, configure credentials (see docs/ for instructions) and run a publish command such as:
+
+```bash
+# With twine
+python -m pip install --upgrade build twine
+python -m build
+python -m twine upload dist/*
+
+# or with hatch
+hatch publish # requires hatch and configuration
+```
+
+See the docs/ for more information and examples.

dailydotsnek-1.0.0/README.md

@@ -0,0 +1,70 @@
+# dailydotsnek
+
+A lightweight, well-documented Python SDK for the daily.dev public API.
+
+Features
+- Clean, minimal API client interfaces
+- Environment- or manual-token authentication helpers
+- Full method coverage for feeds, posts, bookmarks, profile, and search
+
+Installation
+
+Install from PyPI when the package is published:
+
+```bash
+pip install dailydotsnek
+```
+
+(For local development):
+
+```bash
+pip install -e .
+```
+
+Quickstart
+
+```python
+from snek.tokenSys import AutoApiToken, ManualApiToken
+from snek.snekSDK import SnekSDK
+
+# AutoApiToken reads the DAILY_DEV_KEY env var (via python-dotenv)
+token = AutoApiToken()
+# or
+# token = ManualApiToken("your_api_key_here")
+
+client = SnekSDK(token)
+
+posts = client.getPopularFeed()
+print(posts)
+```
+
+Documentation
+
+A full, polished documentation site is included under `docs/` and configured with MkDocs.
+
+Building the package (locally)
+
+- Build a wheel with hatch (project uses hatchling):
+
+```bash
+python -m pip install -U hatch
+hatch build
+```
+
+- The built artifacts will be in `dist/`.
+
+Publishing (prepare-only):
+
+This repository has been prepared for PyPI publishing. To publish, configure credentials (see docs/ for instructions) and run a publish command such as:
+
+```bash
+# With twine
+python -m pip install --upgrade build twine
+python -m build
+python -m twine upload dist/*
+
+# or with hatch
+hatch publish # requires hatch and configuration
+```
+
+See the docs/ for more information and examples.

dailydotsnek-1.0.0/docs/api.md

@@ -0,0 +1,33 @@
+# API Reference (hand-curated)
+
+This page provides a concise, example-driven reference for the primary `SnekSDK` methods. The SDK wraps the daily.dev public API and returns decoded JSON objects when responses include a JSON body.
+
+## SnekSDK
+
+Create an instance with a token (see Quickstart):
+
+```python
+client = SnekSDK(token)
+```
+
+Key methods
+
+- `getPersonalisedFeed()` — personalized feed for authenticated user
+- `getPopularFeed()` — popular posts
+- `getDiscussedFeed()` — posts with active discussions
+- `getTagFeed(tag)` — posts for a tag
+- `getPost(post_id)` — single post
+
+Bookmarks
+- `getBookmarks()`
+- `addBookmarks(post_ids, list_id=None)`
+- `getBookmarkLists()`
+
+Profile
+- `getProfile()`
+- `updateProfile(**data)`
+
+Search
+- `searchPosts(query)`, `searchTags(query)`, `searchSources(query)`
+
+Refer to the source in `src/snek/snekSDK.py` for the full, up-to-date list of methods and parameter shapes.

dailydotsnek-1.0.0/docs/changelog.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## [1.0.0] - 2026-10-13
+### Added
+- Initial public release
+- Core SDK methods for feeds, posts, bookmarks, profile, and search
+- Basic documentation and examples
+

dailydotsnek-1.0.0/docs/contributing.md

@@ -0,0 +1,32 @@
+# Contributing
+
+Thanks for considering contributing to dailydotsnek! This project welcomes improvements to documentation, bug fixes, and new features.
+
+Guidelines
+
+- Open an issue to discuss larger changes before implementing.
+- Fork the repo and create a topic branch for your change.
+- Keep changes small and focused; write tests for new behaviors.
+
+Code style
+
+- Target Python 3.10+.
+- Use type hints where helpful.
+- Keep public API backwards-compatible.
+
+Testing
+
+Add tests under a `tests/` directory and run with `pytest`.
+
+Documentation
+
+Docs are written in Markdown and built with MkDocs. To preview locally:
+
+```bash
+pip install mkdocs mkdocs-material
+mkdocs serve
+```
+
+License
+
+This project is licensed under the MIT License.

dailydotsnek-1.0.0/docs/index.md

@@ -0,0 +1,13 @@
+# dailydotsnek
+
+Welcome to the official documentation for dailydotsnek — a polished, developer-friendly Python SDK for the daily.dev public API.
+
+This documentation is designed to be concise, readable, and example-driven. Use the navigation on the left to find installation instructions, a quickstart, API reference, contributing guidelines, and changelog.
+
+Highlights
+
+- Ergonomic token helpers (AutoApiToken / ManualApiToken)
+- A single SnekSDK client with convenience methods for feeds, posts, bookmarks, profile, and search
+- Designed for Python 3.10+
+
+If you're new here, start with Installation and Quickstart for a 2-minute walkthrough.

dailydotsnek-1.0.0/docs/installation.md

@@ -0,0 +1,20 @@
+# Installation
+
+Install the published package from PyPI (when available):
+
+```bash
+pip install dailydotsnek
+```
+
+For local development, install in editable mode:
+
+```bash
+python -m pip install -U pip
+python -m pip install -e .
+```
+
+Requirements
+- Python 3.10+
+- Optional: python-dotenv if using AutoApiToken
+
+Virtual environments are recommended for development and testing.

dailydotsnek-1.0.0/docs/publishing.md

@@ -0,0 +1,46 @@
+# Publishing to TestPyPI / PyPI
+
+This project is prepared for PyPI publishing using standard tools. Two common approaches are described below.
+
+Prerequisites
+
+- Python 3.10+ installed
+- An account on Test PyPI (https://test.pypi.org/) and/or PyPI (https://pypi.org/)
+- `twine` and `build` installed locally
+
+Create a `.pypirc` (optional)
+
+Create `~/.pypirc` to store credentials so `twine` can pick them up automatically:
+
+```
+[distutils]
+index-servers =
+    pypi
+    testpypi
+
+[pypi]
+username = __token__
+password = <pypi-api-token>
+
+[testpypi]
+repository: https://test.pypi.org/legacy/
+username = __token__
+password = <testpypi-api-token>
+```
+
+Build and upload (TestPyPI recommended first)
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+# Upload to test PyPI
+python -m twine upload --repository testpypi dist/*
+
+# After verification, upload to real PyPI
+python -m twine upload dist/*
+```
+
+Notes
+
+- Use API tokens rather than your account password. Create them in your PyPI account settings.
+- For automated releases, use GitHub Actions or another CI; keep tokens in repository secrets and restrict publish jobs.

dailydotsnek-1.0.0/docs/usage.md

@@ -0,0 +1,37 @@
+# Quickstart & Usage
+
+## Authentication
+
+Two token helpers are provided:
+
+- `AutoApiToken()` — loads `DAILY_DEV_KEY` from environment using python-dotenv.
+- `ManualApiToken("<token>")` — provide token explicitly.
+
+```python
+from snek.tokenSys import AutoApiToken, ManualApiToken
+from snek.snekSDK import SnekSDK
+
+# Auto (dotenv)
+token = AutoApiToken()
+client = SnekSDK(token)
+
+# Manual
+# token = ManualApiToken("sk_live_...")
+# client = SnekSDK(token)
+```
+
+## Example: get popular feed
+
+```python
+posts = client.getPopularFeed()
+for p in posts.get("data", []):
+    print(p.get("title"))
+```
+
+## Error handling
+
+The client surface raises requests HTTP errors on non-2xx responses. Catch `requests.HTTPError` to handle API errors.
+
+## Rate limits
+
+Use `getRateLimit()`, `getRateRemaining()` and `getRateResetTime()` to inspect API rate-limit headers.

dailydotsnek-1.0.0/mapper.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+import ast
+from pathlib import Path
+
+
+IGNORED_DIRS = {
+    "__pycache__",
+    ".git",
+    ".venv",
+    "venv",
+    "node_modules",
+}
+
+
+def find_symbols(path: Path) -> list[str]:
+    """Return public functions/classes defined directly in a Python file."""
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    except SyntaxError as exc:
+        print(f"warning: could not parse {path}: {exc}")
+        return []
+
+    symbols: list[str] = []
+
+    for node in tree.body:
+        if isinstance(
+            node,
+            (
+                ast.FunctionDef,
+                ast.AsyncFunctionDef,
+                ast.ClassDef,
+            ),
+        ):
+            if not node.name.startswith("_"):
+                symbols.append(node.name)
+
+    return sorted(symbols)
+
+
+def python_files(directory: Path) -> list[Path]:
+    """Find Python files directly inside a directory."""
+    return sorted(
+        path
+        for path in directory.iterdir()
+        if path.is_file()
+        and path.suffix == ".py"
+        and path.name != "__init__.py"
+    )
+
+
+def package_directories(src: Path) -> list[Path]:
+    """Find every directory containing Python/package code."""
+    directories: set[Path] = set()
+
+    for path in src.rglob("*"):
+        if not path.is_dir():
+            continue
+
+        if any(part in IGNORED_DIRS for part in path.parts):
+            continue
+
+        if any(path.glob("*.py")):
+            directories.add(path)
+
+    # Include parents so nested packages get __init__.py files too.
+    for directory in list(directories):
+        current = directory
+        while current != src and current != current.parent:
+            directories.add(current)
+            current = current.parent
+
+    return sorted(directories)
+
+
+def module_import(module: str, symbols: list[str]) -> str:
+    """Create an import line for a module."""
+    if symbols:
+        names = ", ".join(symbols)
+        return f"from .{module} import {names}"
+
+    return f"from . import {module}"
+
+
+def generate_init(directory: Path, src: Path) -> str:
+    """Generate the contents of an __init__.py."""
+    files = python_files(directory)
+
+    lines = [
+        '"""Automatically generated package exports."""',
+        "",
+    ]
+
+    # Export functions/classes from Python files.
+    for file in files:
+        symbols = find_symbols(file)
+        module = file.stem
+
+        lines.append(module_import(module, symbols))
+
+    # Export child packages.
+    child_packages = []
+
+    for child in sorted(directory.iterdir()):
+        if not child.is_dir():
+            continue
+
+        if child.name in IGNORED_DIRS:
+            continue
+
+        if any(child.glob("*.py")) or any(child.iterdir()):
+            child_packages.append(child.name)
+
+    if files and child_packages:
+        lines.append("")
+
+    for package in child_packages:
+        lines.append(f"from . import {package}")
+
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def map_src(src: Path, *, dry_run: bool = False) -> None:
+    if not src.exists():
+        raise FileNotFoundError(f"Source directory does not exist: {src}")
+
+    if not src.is_dir():
+        raise NotADirectoryError(f"Not a directory: {src}")
+
+    directories = package_directories(src)
+
+    for directory in directories:
+        init_file = directory / "__init__.py"
+        content = generate_init(directory, src)
+
+        if dry_run:
+            print(f"\n### {init_file}")
+            print(content)
+            continue
+
+        init_file.write_text(content, encoding="utf-8")
+        print(f"generated {init_file}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Generate __init__.py exports for a Python src/ tree."
+    )
+
+    parser.add_argument(
+        "src",
+        nargs="?",
+        type=Path,
+        default=Path("src"),
+        help="Source directory (default: src)",
+    )
+
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print generated files without modifying anything.",
+    )
+
+    args = parser.parse_args()
+
+    map_src(args.src, dry_run=args.dry_run)
+
+
+if __name__ == "__main__":
+    main()

dailydotsnek-1.0.0/mkdocs.yml

@@ -0,0 +1,24 @@
+site_name: dailydotsnek
+site_description: "Professional documentation for the dailydotsnek Python SDK"
+site_author: "Your Name"
+repo_url: https://github.com/yourusername/dailydotsnek
+
+nav:
+  - Home: index.md
+  - Installation: installation.md
+  - Quickstart: usage.md
+  - API Reference: api.md
+  - Contributing: contributing.md
+  - Changelog: changelog.md
+
+theme:
+  name: material
+  palette:
+    primary: 'indigo'
+    accent: 'indigo'
+
+markdown_extensions:
+  - admonition
+  - codehilite
+  - toc:
+      permalink: true

dailydotsnek-1.0.0/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dailydotsnek"
+version = "1.0.0"
+description = "Python SDK for Daily.dev api"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/snek"]

dailydotsnek-1.0.0/src/snek/rawFetch.py

@@ -0,0 +1,109 @@
+
+import requests
+
+from .tokenSys import ManualApiToken, AutoApiToken
+
+
+class RawFetch:
+    def __init__(self, token: ManualApiToken | AutoApiToken):
+        self.token = token
+        self.base_url = "https://api.daily.dev/public/v1"
+
+    def fetch(
+        self,
+        endpoint: str,
+        method: str = "GET",
+        params: dict | None = None,
+        json: dict | list | None = None,
+    ):
+        url = f"{self.base_url}/{endpoint.lstrip('/')}"
+
+        headers = {
+            "Authorization": f"Bearer {self.token.get_token()}",
+            "Accept": "application/json",
+        }
+
+        response = requests.request(
+            method=method,
+            url=url,
+            headers=headers,
+            params=params,
+            json=json,
+        )
+
+        if response.ok:
+            # Some successful requests may return no body.
+            if not response.content:
+                return None
+
+            return response.json()
+
+        response.raise_for_status()
+
+    # ─────────────────────────────────────────────
+    # Convenience methods
+    # ─────────────────────────────────────────────
+
+    def get(
+        self,
+        endpoint: str,
+        params: dict | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="GET",
+            params=params,
+        )
+
+    def post(
+        self,
+        endpoint: str,
+        json: dict | list | None = None,
+        params: dict | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="POST",
+            params=params,
+            json=json,
+        )
+
+    def put(
+        self,
+        endpoint: str,
+        json: dict | list | None = None,
+        params: dict | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="PUT",
+            params=params,
+            json=json,
+        )
+
+    def patch(
+        self,
+        endpoint: str,
+        json: dict | list | None = None,
+        params: dict | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="PATCH",
+            params=params,
+            json=json,
+        )
+
+    def delete(
+        self,
+        endpoint: str,
+        params: dict | None = None,
+        json: dict | list | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="DELETE",
+            params=params,
+            json=json,
+        )
+

dailydotsnek-1.0.0/src/snek/rawFetch_fixed.py

@@ -0,0 +1,107 @@
+import requests
+
+from .tokenSys import ManualApiToken, AutoApiToken
+
+
+class RawFetch:
+    def __init__(self, token: ManualApiToken | AutoApiToken):
+        self.token = token
+        self.base_url = "https://api.daily.dev/public/v1"
+
+    def fetch(
+        self,
+        endpoint: str,
+        method: str = "GET",
+        params: dict | None = None,
+        json: dict | list | None = None,
+    ):
+        url = f"{self.base_url}/{endpoint.lstrip('/') }"
+
+        headers = {
+            "Authorization": f"Bearer {self.token.get_token()}",
+            "Accept": "application/json",
+        }
+
+        response = requests.request(
+            method=method,
+            url=url,
+            headers=headers,
+            params=params,
+            json=json,
+        )
+
+        if response.ok:
+            # Some successful requests may return no body.
+            if not response.content:
+                return None
+
+            return response.json()
+
+        response.raise_for_status()
+
+    # ─────────────────────────────────────────────
+    # Convenience methods
+    # ─────────────────────────────────────────────
+
+    def get(
+        self,
+        endpoint: str,
+        params: dict | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="GET",
+            params=params,
+        )
+
+    def post(
+        self,
+        endpoint: str,
+        json: dict | list | None = None,
+        params: dict | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="POST",
+            params=params,
+            json=json,
+        )
+
+    def put(
+        self,
+        endpoint: str,
+        json: dict | list | None = None,
+        params: dict | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="PUT",
+            params=params,
+            json=json,
+        )
+
+    def patch(
+        self,
+        endpoint: str,
+        json: dict | list | None = None,
+        params: dict | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="PATCH",
+            params=params,
+            json=json,
+        )
+
+    def delete(
+        self,
+        endpoint: str,
+        params: dict | None = None,
+        json: dict | list | None = None,
+    ):
+        return self.fetch(
+            endpoint,
+            method="DELETE",
+            params=params,
+            json=json,
+        )

dailydotsnek-1.0.0/src/snek/snekSDK.py

@@ -0,0 +1,239 @@
+
+import requests
+
+from .tokenSys import ManualApiToken, AutoApiToken
+from .rawFetch_fixed import RawFetch
+
+
+class SnekSDK:
+    def __init__(self, token: ManualApiToken | AutoApiToken):
+        self.token = token
+        self.base_url = "https://api.daily.dev/public/v1"
+        self.fetch = RawFetch(token=self.token)
+
+
+
+    def getRateLimit(self):
+        return self.fetch.fetch("x-ratelimit-limit")
+
+    def getRateRemaining(self):
+        return self.fetch.fetch("x-ratelimit-remaining")
+
+    def getRateResetTime(self):
+        return self.fetch.fetch("x-ratelimit-reset")
+
+    def getRetryTime(self):
+        return self.fetch.fetch("retry-after")
+
+
+    def getPersonalisedFeed(self):
+        return self.fetch.fetch("feeds/foryou")
+
+    def getPopularFeed(self):
+        return self.fetch.fetch("feeds/popular")
+
+    def getDiscussedFeed(self):
+        return self.fetch.fetch("feeds/discussed")
+
+    def getTagFeed(self, tag: str):
+        return self.fetch.fetch(f"feeds/tag/{tag}")
+
+    def getSourceFeed(self, source: str):
+        return self.fetch.fetch(f"feeds/source/{source}")
+
+
+
+    def getPost(self, post_id: str):
+        return self.fetch.fetch(f"posts/{post_id}")
+
+    def getPostComments(self, post_id: str):
+        return self.fetch.fetch(f"posts/{post_id}/comments")
+
+
+
+    def searchPosts(self, query: str):
+        return self.fetch.fetch("search/posts", params={"q": query})
+
+    def searchTags(self, query: str):
+        return self.fetch.fetch("search/tags", params={"q": query})
+
+    def searchSources(self, query: str):
+        return self.fetch.fetch("search/sources", params={"q": query})
+
+
+
+    def getBookmarks(self):
+        return self.fetch.fetch("bookmarks/")
+
+    def addBookmarks(self, post_ids: list[str], list_id: str | None = None):
+        data: dict[str, object] = {
+            "postIds": post_ids,
+        }
+
+        if list_id is not None:
+            data["listId"] = list_id
+
+        return self.fetch.fetch(
+            "bookmarks/",
+            method="POST",
+            json=data,
+        )
+
+    def searchBookmarks(self, query: str):
+        return self.fetch.fetch(
+            "bookmarks/search",
+            params={"q": query},
+        )
+
+    def getBookmarkLists(self):
+        return self.fetch.fetch("bookmarks/lists")
+
+    def createBookmarkList(self, name: str, icon: str | None = None):
+        data = {
+            "name": name,
+        }
+
+        if icon is not None:
+            data["icon"] = icon
+
+        return self.fetch.fetch(
+            "bookmarks/lists",
+            method="POST",
+            json=data,
+        )
+
+    def deleteBookmarkList(self, list_id: str):
+        return self.fetch.fetch(
+            f"bookmarks/lists/{list_id}",
+            method="DELETE",
+        )
+
+    def deleteBookmark(self, bookmark_id: str):
+        return self.fetch.fetch(
+            f"bookmarks/{bookmark_id}",
+            method="DELETE",
+        )
+
+    def moveBookmark(self, bookmark_id: str, list_id: str | None):
+        return self.fetch.fetch(
+            f"bookmarks/{bookmark_id}",
+            method="PATCH",
+            json={
+                "listId": list_id,
+            },
+        )
+
+
+
+    def getProfile(self):
+        return self.fetch.fetch("profile")
+
+    def updateProfile(self, **data):
+        return self.fetch.fetch(
+            "profile",
+            method="PATCH",
+            json=data,
+        )
+
+
+
+    def searchStack(self, query: str):
+        return self.fetch.fetch(
+            "profile/stack/search",
+            params={"q": query},
+        )
+
+    def getStack(self):
+        return self.fetch.fetch("profile/stack/")
+
+    def addStackItem(self, **data):
+        return self.fetch.fetch(
+            "profile/stack/",
+            method="POST",
+            json=data,
+        )
+
+    def updateStackItem(self, item_id: str, **data):
+        return self.fetch.fetch(
+            f"profile/stack/{item_id}",
+            method="PATCH",
+            json=data,
+        )
+
+    def deleteStackItem(self, item_id: str):
+        return self.fetch.fetch(
+            f"profile/stack/{item_id}",
+            method="DELETE",
+        )
+
+    def reorderStack(self, **data):
+        return self.fetch.fetch(
+            "profile/stack/reorder",
+            method="PUT",
+            json=data,
+        )
+
+
+
+    def getExperiences(self):
+        return self.fetch.fetch("profile/experiences/")
+
+    def createExperience(self, **data):
+        return self.fetch.fetch(
+            "profile/experiences/",
+            method="POST",
+            json=data,
+        )
+
+    def getExperience(self, experience_id: str):
+        return self.fetch.fetch(
+            f"profile/experiences/{experience_id}",
+        )
+
+    def updateExperience(self, experience_id: str, **data):
+        return self.fetch.fetch(
+            f"profile/experiences/{experience_id}",
+            method="PUT",
+            json=data,
+        )
+
+    def deleteExperience(self, experience_id: str):
+        return self.fetch.fetch(
+            f"profile/experiences/{experience_id}",
+            method="DELETE",
+        )
+
+
+
+    def getTags(self):
+        return self.fetch.fetch("tags/")
+
+
+
+    def recommendByKeyword(self, keyword: str):
+        return self.fetch.fetch(
+            "recommend/keyword",
+            params={"keyword": keyword},
+        )
+
+    def recommendSemantic(self, **params):
+        """
+        Deprecated by daily.dev.
+        Prefer recommendByKeyword().
+        """
+        return self.fetch.fetch(
+            "recommend/semantic",
+            params=params,
+        )
+
+
+    def signup(self, **data):
+        return self.fetch.fetch(
+            "signup/",
+            method="POST",
+            json=data,
+        )
+
+
+    
+    

dailydotsnek-1.0.0/src/snek/tokenSys.py

@@ -0,0 +1,20 @@
+import os
+import dotenv
+
+class ManualApiToken:
+    def __init__(self, token: str):
+        self.token = token
+
+    def get_token(self) -> str:
+        return self.token
+
+class AutoApiToken:
+    """
+    Works ONLY if you have a enviroment variable named DAILY_DEV_KEY.
+    """
+    def __init__(self):
+        dotenv.load_dotenv() 
+        self.token = os.getenv("DAILY_DEV_KEY")  
+
+    def get_token(self) -> str:
+            return str(self.token)