creddit 0.0.1__py3-none-any.whl

creddit/__init__.py

@@ -0,0 +1,5 @@
+"""
+creddit - A CLI client for Reddit
+"""
+
+from .terminal import run as run

creddit/__main__.py

@@ -0,0 +1,4 @@
+from creddit.terminal import run
+
+if __name__ == "__main__":
+    run()

creddit/config.py

@@ -0,0 +1,113 @@
+"""
+A file that stores all the variables that much be read from the env file. Helps me keep track of them at one place, instead of reading and using them where they are needed. This application relies on env for config.
+
+Config is store in a JSON file. TOML, YAML, and ini were options but
+
+TOML - built in library can't write. Don't want to package another module.
+YAML - Built in and ugly
+.ini - Ugly
+
+"""
+
+from json import JSONDecodeError
+from json import dump as json_dump
+from json import load as json_load
+from os import getenv
+from pathlib import Path
+from sys import platform
+from typing import Literal, NotRequired, TypedDict
+
+
+class Config(TypedDict):
+    ignored_users: list[str]
+    no_of_posts_to_print: int
+    ignore_all_mod_posts: bool
+    default_subreddit: NotRequired[str]
+
+
+default_config: Config = {
+    "ignored_users": ["2soccer2bot", "AutoModerator"],
+    "no_of_posts_to_print": 10,
+    "ignore_all_mod_posts": True,
+}
+
+config_folder: Path
+
+if platform == "win32":
+    config_folder = Path(getenv("LOCALAPPDATA", "./config/"))
+elif platform == "darwin":
+    config_folder = Path("~/Library/Application Support/")
+elif platform == "linux":
+    config_folder = Path("~/.config/")
+else:
+    config_folder = Path("./config/")
+
+config_folder = config_folder / "creddit"
+config_folder.mkdir(parents=True, exist_ok=True)
+
+# It's actually a cursed thing that you can divide paths.
+config_path: Path = config_folder / "config.json"
+"""The path of the config"""
+
+
+def check_config_existence() -> bool:
+    """Checks if a config file exists, and that it valid
+
+    Returns:
+        bool: True if file exists and contains all required keys
+    """
+    if not Path(config_path).exists():
+        return False
+
+    with open(config_path, "r") as f:
+        try:
+            config = json_load(f)
+        except JSONDecodeError:
+            return False
+        if not (config or (default_config.keys() < config.keys())):
+            return False
+
+    return True
+
+
+def read_config(config_path: Path = config_path) -> Config:
+    """Read the config file"""
+
+    with open(config_path, "r") as f:
+        config: Config = json_load(f)
+
+    required_keys = default_config.keys()
+
+    if required_keys <= config.keys():
+        # Looks like all keys are present
+        return config
+
+    raise RuntimeError("Looks like some values in the config file are missing")
+
+
+def create_config(c: dict | Config = default_config) -> bool:
+    required_keys = default_config.keys()
+
+    if required_keys <= c.keys():
+        # All the must have keys are present
+        with open(config_path, "w+") as f:
+            json_dump(c, f, indent=4, sort_keys=True)
+            return True
+
+    return False
+
+
+def edit_config(new_config: dict) -> bool:
+    c = read_config()
+    key: Literal[
+        "ignored_users",
+        "no_of_posts_to_print",
+        "ignore_all_mod_posts",
+        "default_subreddit",
+    ]
+    for key in new_config:
+        c[key] = new_config[key]
+    with open(config_path, "w") as f:
+        json_dump(c, f, indent=4, sort_keys=True)
+        return True
+    return False

creddit/reddit.py

@@ -0,0 +1,123 @@
+"""
+Manage API connections with and responses from Reddit
+"""
+
+from functools import lru_cache
+
+from requests import get as r_get
+from requests.exceptions import ConnectionError
+
+
+@lru_cache(maxsize=None)
+def get_api_response(url: str) -> dict:
+    """
+    Returns the json-encoded content of the api response, by requesting the given URL using the built-in requests library.
+    Parameters:
+        url (str):URL to load using requests library
+
+    Returns:
+        requests.Response
+    """
+
+    # Caching the resposes for every URL, since I might be calling it again and again for posts/comments, etc, and the response doesn't really change in a few minutes. When the application is run next (after a few hours, days, weeks), it would be running as a fresh instance and the response would be fetched again.
+
+    headers = {
+        "User-Agent": "cli:reddit-cli:v1.0.0 (by /u/vishalnandagopal)"
+        # "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:104.0) Gecko/20100101 Firefox/130.0"
+    }
+    try:
+        api_response = r_get(url=url, headers=headers)
+        if api_response.status_code != 200:
+            raise RuntimeError(f"Error with API - \n{api_response}")
+        return api_response.json()
+    except ConnectionError:
+        raise ConnectionError("You seem to be offline. Try connecting to a network.")
+
+
+def get_posts_in_a_subreddit(
+    subreddit: str, limit: int = 10, after_post: str | None = None
+) -> list[dict]:
+    """
+    Constructs the api_url to load the subreddit, and loads the api_response and returns it as a dict.
+
+    Parameters:
+        limit (int):number of posts that should be present in the json response.
+
+        after_post (int):The posts that are after this id in the feed are loaded.
+
+    For example if you give the ID of the 9th post (eg: yjbttz) and limit=10, the posts 10,11,12 and so on till 19 are loaded.
+
+    Returns
+    Dict: Subreddit response as key value pair of index and post_details.
+    """
+
+    subreddit_url = f"https://api.reddit.com/r/{subreddit}?limit={limit}"
+
+    if after_post:
+        subreddit_url += f"&after=t3_{after_post}"
+
+    subreddit_response = get_api_response(subreddit_url)
+    return subreddit_response["data"]["children"]
+
+
+def get_post_dict(post_id) -> dict:
+    """
+    Constructs the api_url to load the comments of a post, and loads the api_response and returns it as a tuple, with the first element being the post text, and the second element being a dict of the comments.
+
+    Parameters:
+        post_id (str):The ID of the post to load comments for. Eg: yjbttz.
+
+    Returns:
+        dict: The JSON response of the API, parsed as a dict
+    """
+
+    # LRU caching this function doesn't really help, since it only calls the API and returns it. The API function is already cached using the same lru_cache decorator.
+    post_url = f"https://api.reddit.com/{post_id}"
+    return get_api_response(post_url)
+
+
+def get_post_text(post_id: str) -> str:
+    """
+    Fetches the text of the post, if any
+
+    Parameters:
+        post_id (str): The post ID
+
+    Returns:
+        str: The text of the post
+    """
+    try:
+        return get_post_dict(post_id)[0]["data"]["children"][0]["data"]["selftext"]
+    except KeyError:
+        return ""
+
+
+def get_comments_dict(post_id: str) -> dict[int, dict]:
+    """
+    Fetches the dict for the post and returns only a tuple of the text in the post (if any), and the a dict of the comments. the api_url to load the comments of a post, and loads the api_response and returns it as a tuple, with the first element being the post text, and the second element being a dict of the comments.
+
+    Parameters:
+        post_id (str):The ID of the post to load comments for. Eg: yjbttz.
+
+    Returns:
+        dict: The comments dict. Key value pair of int and each comment's dict
+    """
+    post_comments_response = get_post_dict(post_id)
+    return post_comments_response[1]["data"]["children"]
+
+
+def get_link_in_post(post_id: str) -> str:
+    """
+    Fetches the link in the post. If it is a reddit video, it sends the fallback URL so that it links directly to the video. Reddit redirects video links to the post page, which is unecessary
+
+    Parameters:
+        post_id (str): The ID of the post to fetch the posted link
+
+    Returns:
+        str: The link
+    """
+    _ = get_post_dict(post_id)[0]["data"]["children"][0]["data"]
+    if _["is_video"]:
+        return _["media"]["reddit_video"]["fallback_url"]
+    else:
+        return _["url"]

creddit/terminal.py

@@ -0,0 +1,367 @@
+"""
+Handle all terminal functions, such as printing using different colors, taking care of user input after it, etc
+"""
+
+from html import unescape
+from subprocess import Popen as background_run_command
+from subprocess import run as run_command
+from textwrap import TextWrapper
+from typing import Any, Dict
+from urllib.parse import urlparse
+from webbrowser import open as web_open
+
+from colorama import Fore
+
+from .config import Config, check_config_existence, create_config, read_config
+from .reddit import get_link_in_post, get_post_dict, get_posts_in_a_subreddit
+
+colors_to_use_in_terminal: tuple[str, ...] = (
+    Fore.RED,
+    Fore.GREEN,
+    Fore.YELLOW,
+    Fore.CYAN,
+    Fore.MAGENTA,
+)
+# Fore.BLUE is very ugly in the terminal. Ineligible
+
+num_of_colors = len(colors_to_use_in_terminal)
+
+ending_separator = f"\n{'-' * 116}\n"
+
+config: Config
+
+
+ignored_users: list[str]
+"""Posts by these users won't be printed"""
+
+
+no_of_posts_to_print: int
+"""The number of posts to print each time"""
+
+
+ignore_all_mod_posts: bool
+"""Whether to ignore mod posts. Currently not implemented"""
+
+
+def introduce() -> None:
+    """
+    User using the app for the first time? Call this!
+    """
+
+    print(
+        f"Welcome to {Fore.RED}cReddit{Fore.RESET}! Looks like you're using this app for a first time"
+    )
+    if input(
+        f"Would you like set the config (default subreddits, ignored users, etc) [Y/n] [{Fore.GREEN}Y{Fore.RESET}]"
+    ).casefold() in {"", "y"}:
+        c: Dict[str, Any] = dict()
+
+        # No of posts of print
+        c["no_of_posts_to_print"] = int(
+            input(f"No of posts to print in the terminal? [{Fore.GREEN}10{Fore.RESET}]")
+            or 10
+        )
+
+        # Does the user want to ignore any users?
+        c["ignored_users"] = input(
+            f"Users you wish to ignore? (Eg: Automoderator, 2soccer2bot). Separate multiple values with a comma [{Fore.GREEN}2soccer2bot,AutoModerator{Fore.RESET}]"
+        ).split(",")
+        if c["ignored_users"] == [""]:
+            c["ignored_users"] = ["2soccer2bot", "AutoModerator"]
+        c["ignore_all_mod_posts"] = True
+
+        # Maybe the user wants to open a subreddit by default?
+        if input(
+            f"Would you like to open a subreddit by default every time? [Y/n] [{Fore.GREEN}Y{Fore.RESET}]"
+        ).casefold() in {"", "y"}:
+            _ = input("Enter default subreddit - r/")
+            while not _:
+                _ = input("Enter default subreddit - r/")
+
+            c["default_subreddit"] = _
+
+        create_config(c)
+    else:
+        create_config()
+
+
+def exit_terminal(error: Exception | None) -> None:
+    """
+    Exits the terminal and resets the terminal color to the default color:
+    """
+
+    print(Fore.RESET)
+    if error:
+        print(repr(error))
+    exit()
+
+
+def take_input_after_sub_print(text: str) -> str:
+    """
+    After a subreddit's post has been printed, the user's input is taken. He can give any of the 4 as input
+    1. Empty input (by just entering) - Will reach more posts
+    2. Post number - Will open the comments for that post
+    3. Postnumber and "o" (Like "1o") to open the post in the web browser and to read the comments
+    4. r/subreddit_name - Indicates he wants to stop reading this subreddit and continue to another one.
+
+    Parameters:
+        text (str): The text to print while taking input
+
+    Returns:
+        str: The input given
+    """
+    try:
+        user_choice = input(text).casefold()
+        if not user_choice:
+            return ""
+        if (user_choice.endswith("o")) and not user_choice[:-1].isnumeric():
+            raise ValueError("Enter a valid number before the o")
+        if (user_choice.startswith("r/")) and (not user_choice.isalpha()):
+            raise ValueError(
+                "Please enter the name of the subreddit as r/subreddit_name"
+            )
+        if (
+            not (user_choice.endswith("o") or user_choice.startswith("r/"))
+            and not user_choice.isnumeric()
+        ):
+            raise ValueError(
+                'Please enter a valid number to read the comments, "number0" to open the link, or r/subreddit_name to read posts from a different sub'
+            )
+        return user_choice
+    except ValueError as e:
+        print(e)
+        return take_input_after_sub_print(text)
+    except (KeyboardInterrupt, EOFError):
+        print("\nExited the program")
+        exit_terminal(error=None)
+    except Exception as e:
+        exit_terminal(error=e)
+    return ""
+
+
+def handle_user_choice_after_a_post(
+    printed_posts: list[str], titles: list[str], subreddit: str, start_count: int = 0
+) -> None:
+    """
+    After a subs posts are printed, take input using another function and handle it accordingly. Open the comments, the link or another subreddit
+
+    Parameters:
+        printed_posts (list[str]): The list of all post_ids currently printed in the terminal. Used to handle input according to he number the user chooses.
+        titles: (list[str]): The titles of all the posts currently printed in the terminal. Used to quickly print it before fetching comments.
+        subreddit (str): To continue after the last post, in case the user wants to read more posts from the subreddit
+    """
+    user_choice = take_input_after_sub_print(
+        """Enter the post number you want to read the comments for, or click enter to read more posts:\nTo open link and also view comments, type "o" after the number. Like "2o": """
+    )
+    if user_choice.endswith("o") or user_choice.isnumeric():
+        if user_choice.endswith("o"):
+            # Wants to open the post before reading comments
+
+            num_choice = int(user_choice[:-1])
+            open_post_link(printed_posts[num_choice - 1])
+        elif user_choice.isnumeric():
+            # Wants to read comments of a post
+
+            num_choice = int(user_choice)
+            if num_choice > len(printed_posts) or num_choice < 1:
+                print(
+                    f"{Fore.RED}Number must be >= 1 and <= {len(printed_posts)}{Fore.RESET}"
+                )
+                return handle_user_choice_after_a_post(
+                    printed_posts, titles, subreddit, start_count
+                )
+
+        # Colored post title
+        post_title = f"{colors_to_use_in_terminal[(num_choice - 1) % num_of_colors]}{titles[num_choice - 1]}{Fore.RESET}"
+        print(post_title)
+
+        print_post_comments(printed_posts[num_choice - 1])
+        handle_user_choice_after_a_post(printed_posts, titles, subreddit, start_count)
+    else:
+        # Wants to read more posts from the same subreddit
+        last_post_id = printed_posts[-1]
+        print_subreddit_posts(
+            subreddit, post_id_to_start_from=last_post_id, start_count=start_count
+        )
+
+
+def print_subreddit_posts(
+    subreddit: str,
+    post_id_to_start_from: str | None = None,
+    start_count: int = 0,
+) -> None:
+    """
+    Prints the subreddit posts when you give a subreddit name
+
+    subrredit_dict_data is the dict subreddit_dict["data"], and subreddit_dict_data["children"] is a list.
+
+    Parameters:
+        subreddit (str): Name of the subreddit.
+        post_id_to_start_from (str) : Used to connstruct the API url to ensure only the posts needed after a particular post ID are loaded from the server.
+        start_count (int) : Post number to start from in the api_response.
+    """
+
+    subreddit_dict = get_posts_in_a_subreddit(
+        subreddit,
+        limit=(no_of_posts_to_print),
+        after_post=post_id_to_start_from,
+    )
+
+    printed_posts: list[str] = list()
+    titles: list[str] = list()
+    # printed_posts is supposed to be of the format ["post_id",...], where printed_posts[i-1] is the id of the i'th post printed in the terminal
+
+    print(f"r/{subreddit}", end="\n\n")
+    for entry in subreddit_dict:
+        if entry["data"]["author"] not in ignored_users:
+            print_post_body(entry, start_count)
+            printed_posts.append(entry["data"]["id"])
+            titles.append(entry["data"]["title"])
+            start_count += 1
+
+    print(Fore.RESET, end="")
+
+    handle_user_choice_after_a_post(printed_posts, titles, subreddit, start_count)
+
+
+def print_post_body(specific_entry: dict[str, dict], start_count: int) -> None:
+    """
+    Called from `print_subreddit_posts()`, this functions handles the printing of a body content for a post.
+
+    Parameters:
+    specific_entry dict[str,dict]: Dict containing details of a comments, fetched using the Reddit API.
+    """
+
+    print(
+        colors_to_use_in_terminal[start_count % num_of_colors]
+        + f"{start_count + 1}. {unescape(specific_entry['data']['title'])}"
+    )
+    try:
+        if (
+            specific_entry["data"]["link_flair_richtext"][1]["t"].lower()
+            == "official source"
+        ):
+            post_url_source = (
+                f"    URL - {specific_entry['data']['url']}\n    Official Source"
+            )
+        else:
+            post_url_source = f"    URL - {specific_entry['data']['url']}"
+    except (KeyError, IndexError):
+        post_url_source = f"    URL - {specific_entry['data']['url']}"
+    print(
+        f"{post_url_source}{Fore.RESET}",
+        end=ending_separator,
+    )
+
+
+def print_comment(specific_comment_entry: dict) -> None:
+    """
+    Called from `print_post_comments()`, this functions handles the printing for a specific comment
+
+    Parameters:
+    specific_entry (str): Dict containing details of a comments, fetched using the Reddit API.
+    """
+
+    prefix = """    |
+    |--- """
+    wrapper = TextWrapper(
+        initial_indent=prefix, width=150, subsequent_indent="    |    "
+    )
+    # Prints the comment text and it's author by giving the correct indendation to the left.
+    print(
+        wrapper.fill(
+            unescape(specific_comment_entry["body"])
+            + " --- u/"
+            + unescape(specific_comment_entry["author"])
+        )
+    )
+
+
+def print_post_comments(post_id: str) -> None:
+    """
+    Prints the subreddit posts when you give a subreddit name
+
+    printed_posts is supposed to be of the format ["post_id"], where printed_posts[i-1] is the id of the i'th post printed in the terminal
+
+    Parameters:
+        post_id (str): ID of the post for which we have to load comments.
+        post_title (str): The title of the post to print before printing out the comments
+    """
+
+    post_comments_dict = get_post_dict(post_id)[1]["data"]["children"]
+    count = 0
+
+    for entry in post_comments_dict:
+        if count < 10:
+            if entry["data"]["author"] not in ignored_users:
+                print_comment(entry["data"])
+                count += 1
+        else:
+            break
+
+    print(Fore.RESET, end=ending_separator)
+
+
+def open_post_link(post_id: str) -> None:
+    """
+    When the link mentioned in a post is passed to this, it tries to determine if it is a video that can be opened in MPV. If possible, it opens it directly in MPV. Else, for other links, it opens it in the defauly web browser using the `webbrowser` module.
+
+    Parameters:
+        post_id (str):
+    """
+
+    link = get_link_in_post(post_id)
+    domain = str(urlparse(link).netloc)
+    if domain.casefold() in {
+        "v.redd.it",
+    }:
+        if run_command(["mpv", "--version"]):
+            print("Opening it in MPV")
+            # Open the video using MPV in a loop
+            background_run_command(["mpv", link, "--loop"])
+        else:
+            print("Opening in browser")
+            web_open(link)
+    else:
+        web_open(link)
+
+
+def cls() -> None:
+    """This somehow clears the screen. https://stackoverflow.com/a/50560686"""
+    print("\033[H\033[J", end="")
+
+
+def run() -> None:
+    """
+    Callable function to be used while running from the terminal
+    """
+    global \
+        config, \
+        ignored_users, \
+        no_of_posts_to_print, \
+        ignore_all_mod_posts, \
+        default_subreddit
+
+    # Clear screen
+    cls()
+
+    if not check_config_existence():
+        introduce()
+
+    config = read_config()
+
+    ignored_users = config["ignored_users"]
+
+    no_of_posts_to_print = int(config["no_of_posts_to_print"])
+    subreddit = (
+        str(config["default_subreddit"])
+        if "default_subreddit" in config
+        else input("Enter the subreddit you want to visit: r/")
+    )
+
+    ignore_all_mod_posts = bool(config["ignore_all_mod_posts"])
+
+    if not subreddit:
+        print("No subreddit entered.")
+        exit_terminal(error=None)
+    print_subreddit_posts(subreddit)

creddit-0.0.1.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: creddit
+Version: 0.0.1
+Summary: An unofficial cli client for Reddit, aimed at people who regularly browse specific subreddits or topics instead of reading the homepage (r/all).
+Author-email: Vishal Nandagopal <dev@vishalnandagopal.com>
+License-Expression: MIT
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: requests>=2.32.3
+Dynamic: license-file
+
+# creddit - A CLI client for Reddit
+
+An unofficial cli client for Reddit, aimed at people who regularly browse specific subreddits or topics instead of reading the homepage (r/all).
+
+### Features:
+
+-   Distraction free. Can browse a few posts and continue with your day. No flashy gifs, awards, ads or posts.
+
+-   Browse a subreddit by entering just the name.
+
+-   Prints a link to the article mentioned in every post, for you to continue reading it in your browser (`ctrl+click`), in case you are interested.
+
+-   Can browse top comments for every post just by entering the number shown beside the post in the terminal.
+
+Feel free to send a PR with any additional features, or make an issue if you have any feature requests!
+
+This source code is licensed under the MIT license found in the LICENSE file in the root directory of this source tree.
+
+### How to use?
+
+Clone the repo and install the thing as a package
+
+```sh
+git clone --depth 1 https://github.com/vishalnandagopal/creddit/ creddit
+cd creddit
+pip install uv
+uv sync
+uv build
+pip install ./dist/creddit-1.0.0-py3-none-any.whl
+```
+
+And to finally run it,
+
+```sh
+python -m creddit
+```
+
+### Features to add
+
+-   Publish to pip
+-   More guidance on MPV, and alternatives if it isn't installed
+
+(Copyright (c) 2024 Vishal N)

creddit-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+creddit/__init__.py,sha256=D6gRU_goqZR58NMSDfgdiWMVi20YDsBRUDUQxT66EGM,81
+creddit/__main__.py,sha256=fKdyZ_tkgzfFwJkC98x6-eXBYcXMyEmFKBBXAWjwUQU,75
+creddit/config.py,sha256=ngZ9qYM9_NVbMAcvEQ81fRY6Ohz3InW0KSUVydXPYso,3204
+creddit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+creddit/reddit.py,sha256=ugmtumjWw2GdqiAwbuO_gyco3U1z6dG3dMa2BWlwZZ0,4605
+creddit/terminal.py,sha256=SNLDZQWs2NbbU2wysG5D7sN9l11IosgexDTgjz0TtSY,12855
+creddit-0.0.1.dist-info/licenses/LICENSE,sha256=TfGELALVa4NFNIOMn6asE14LycjEIGoHL6O8fm0WRHU,1105
+creddit-0.0.1.dist-info/METADATA,sha256=jzDRIX5qiRR0w79hxZ7j8g9ypN8coCZOel9sPYm0sJc,1835
+creddit-0.0.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+creddit-0.0.1.dist-info/top_level.txt,sha256=Q2-CEVcpBfG-GG9VrGszVWASy03D0PcOpYUvTnugl-0,8
+creddit-0.0.1.dist-info/RECORD,,

creddit-0.0.1.dist-info/WHEEL

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

creddit-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 Vishal N
+
+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 (including the next paragraph) 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.

creddit-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+creddit