ifuse 0.3.6__py3-none-any.whl

anomlib/argparser.py

@@ -0,0 +1,315 @@
+"""Parse command line arguments.
+
+Sub commands are supported by arglib.
+Nested sub commands for arglib are not planned yet."""
+
+# Note: This code was vibe-coded as i got bored
+# I had paramparser that worked, but dont wanna play parsing anymore
+# I promise i will replace these vibes with blood, sweat and tears
+import argparse
+
+import anomlib.confman
+
+# DATA = anomlib.confman.Conflock("params/anomtool.toml").load()
+
+
+# Compatibility with optparse-style type names.
+TYPE_NAMES = {
+    "string": str,
+    "int": int,
+    "integer": int,
+    "float": float,
+}
+
+# Default structure to support arguments
+ARGS = {
+    "class": "arg",
+    "nargs": "*",
+    "type": "string",
+    "help": "Input files and other positional arguments",
+}
+
+DRAFTS = {
+    "diff": {
+        "patch": {
+            "class": "flag",
+            "shorts": "pu",
+            "help": "Generate patch",
+            "default": True,
+        },
+        "output": {
+            "class": "value",
+            "shorts": "o",
+            "keys": ["file"],
+            "type": "string",
+            "help": "Write output to a file",
+        }
+    },
+}
+
+
+class ArgParser:
+    "ArgParser handles one sub command"
+    def __init__(self, command, drafts=None, parser=None):
+        self.command = command
+        self.drafts = DRAFTS if drafts is None else drafts
+        self.parser = (
+            parser
+            if parser is not None
+            else argparse.ArgumentParser()
+        )
+        self.build()
+
+    def build(self):
+        try:
+            self.params = self.drafts[self.command]
+            # Support all args
+            self.params["args"] = ARGS
+        except KeyError:
+            print(self.drafts)
+            raise ValueError(
+                f"Unknown command: {self.command!r}"
+            )
+
+        for name, config in self.params.items():
+            self.add_option(name, config)
+
+        return self
+
+    def add_option(self, name, params):
+        """
+        Dispatch an option or positional argument to its handler.
+
+        Supported classes:
+
+            "flag"   Boolean option
+            "value"  Option that accepts a value
+            "arg"    Positional argument
+        """
+        params = dict(params)
+        option_class = params.pop("class", "value")
+
+        handler = getattr(
+            self,
+            f"add_{option_class}",
+            None,
+        )
+
+        if handler is None:
+            raise ValueError(
+                f"Unsupported option class: {option_class!r}"
+            )
+
+        return handler(name, params)
+
+    def add_flag(self, name, params):
+        """
+        Add a Boolean option and its negative aliases.
+
+        Example:
+
+            --patch
+            --no-patch
+            --non-patch
+        """
+        params = dict(params)
+
+        shorts = params.pop("shorts", "")
+        keys = params.pop("keys", [])
+        dest = params.setdefault("dest", name)
+
+        positive_params = dict(params)
+        positive_params.update({
+            "action": "count",
+            "dest": dest,
+        })
+
+        self._add_option_argument(
+            name=name,
+            shorts=shorts,
+            keys=keys,
+            params=positive_params,
+        )
+
+        # SUPPRESS prevents the negative option from replacing the
+        # default defined by the positive option.
+        self.parser.add_argument(
+            f"--no-{name}",
+            f"--non-{name}",
+            action="store_false",
+            dest=dest,
+            default=argparse.SUPPRESS,
+        )
+
+        return self
+
+    def add_value(self, name, params):
+        """
+        Add an option that accepts a value.
+
+        Example:
+
+            --output changes.diff
+            -o changes.diff
+        """
+        params = dict(params)
+
+        shorts = params.pop("shorts", "")
+        keys = params.pop("keys", [])
+
+        self._convert_type(params)
+
+        return self._add_option_argument(
+            name=name,
+            shorts=shorts,
+            keys=keys,
+            params=params,
+        )
+
+    def add_arg(self, name, params):
+        """
+        Add a positional argument.
+
+        Example configuration:
+
+            "args": {
+                "class": "arg",
+                "nargs": "*",
+            }
+
+        This allows:
+
+            program file1.txt --output result.diff file2.txt
+        """
+        params = dict(params)
+
+        # These settings apply to options, not positional arguments.
+        params.pop("shorts", None)
+        params.pop("keys", None)
+
+        self._convert_type(params)
+
+        self.parser.add_argument(
+            name,
+            **params,
+        )
+
+        return self
+
+    def _add_option_argument(
+        self,
+        name,
+        shorts="",
+        keys=None,
+        params=None,
+    ):
+        """
+        Add an optional argument with short and long aliases.
+
+        A string such as "pu" becomes:
+
+            -p
+            -u
+        """
+        keys = [] if keys is None else keys
+        params = {} if params is None else params
+
+        option_strings = [
+            *(f"-{short}" for short in shorts),
+            f"--{name}",
+            *(
+                key if key.startswith("-") else f"--{key}"
+                for key in keys
+            ),
+        ]
+
+        self.parser.add_argument(
+            *option_strings,
+            **params,
+        )
+
+        return self
+
+    @staticmethod
+    def _convert_type(params):
+        """
+        Convert type names such as "string" and "int" into
+        callables accepted by argparser.
+        """
+        value_type = params.get("type")
+
+        if not isinstance(value_type, str):
+            return
+
+        try:
+            params["type"] = TYPE_NAMES[value_type]
+        except KeyError:
+            raise ValueError(
+                f"Unsupported option type: {value_type!r}"
+            )
+
+    def parse_args(self, args=None):
+        """
+        Parse options and interspersed positional arguments.
+
+        Unlike regular parse_args(), parse_intermixed_args() allows
+        positional arguments to appear before, between, and after
+        optional arguments.
+        """
+        try:
+            namespace = self.parser.parse_intermixed_args(args)
+        except AttributeError:
+            raise RuntimeError(
+                "Intermixed argument parsing requires Python 3.7 "
+                "or newer."
+            )
+
+        return vars(namespace)
+
+    def merge_parser_arguments(self, source):
+        """Add arguments from source to target unless target already defines them."""
+
+        target_dests = {
+            action.dest
+            for action in self.parser._actions
+            if action.dest != "help"
+        }
+
+        target_options = {
+            option
+            for action in self.parser._actions
+            for option in action.option_strings
+        }
+
+        for action in source._actions:
+            if action.dest == "help":
+                continue
+
+            # A has redefined this argument
+            if action.dest in target_dests:
+                continue
+
+            # Avoid option-string collisions too
+            if any(option in target_options for option in action.option_strings):
+                continue
+
+            self.parser._add_action(action)
+
+            target_dests.add(action.dest)
+            target_options.update(action.option_strings)
+
+
+def test_argparser(command, *args, **kwargs):
+    parser = ArgParser(command, *args, **kwargs)
+
+    # values = parser.parse_args(["1", "-s", "foo", "bye"])
+    # print(values)
+
+    values = parser.parse_args()
+    print(values)
+
+
+# if __name__ == "__main__":
+#     test_argparser("diff")
+#     # test_argparser("pull", drafts=DATA)
+#     # test_argparser("master", drafts=DATA)

anomlib/builtin/do.py

@@ -0,0 +1,69 @@
+"4g-with is a REPL command that allows calling commands in a loop while changing only args for it."
+
+from pathlib import Path
+
+
+import subprocess, re
+import sys, tarfile, stat 
+import hashlib, time
+
+
+import logging, os, sys
+
+import anomlib.shell
+import anomlib.pillow
+
+home = Path.home()
+
+anomtoolDoCache = home / ".cache/anomtool/do"
+anomtoolDoHistory = anomtoolDoCache / "history"
+anomtoolDoLog = anomtoolDoCache / "do.log"
+
+
+anomlib.pillow.mkdirs(str(anomtoolDoCache))
+anomlib.pillow.mkdirs(str(anomtoolDoHistory))
+
+
+# Configure logging
+
+logging.basicConfig(filename=anomtoolDoLog, level=logging.DEBUG)
+
+# Log messages
+
+
+def inputline(
+        color = "Yellow",
+        prompt = "% ",
+        history = "",
+        readline = "rlwrap",
+        args = sys.argv[1:]
+    ):
+    """Wrapper around readline tool (the rlwrap, a wrapper around gnu-readline in C)
+    
+    i can use any readline library when i figure out how to do it.
+    Why so many wrappers? First make it work! Then make it beautiful!"""
+    _history = history if history else " ".join(args)
+    _history = anomtoolDoHistory / f"{_history}_history"
+    return anomlib.shell.read_command(f"{readline} -p{color} -S '{prompt}' -H '{_history}' -o cat")
+
+
+## Do will support params, but they needs to be added via --param=key=<value> or --param=flag, etc.
+## each --param call will update params dictionary.
+
+def do_repl(*args, **kwargs):
+    command = " ".join(kwargs["args"])
+    print("kwargs:", kwargs)
+    "main function for 'anomtool do'"
+    while True:
+        cmd = inputline(**kwargs)
+        print(cmd)
+        if cmd == "exit":
+            logging.debug(f"at-do: exiting command: {kwargs["args"]}")
+            break
+        elif not cmd:
+            logging.debug(f'at-do: do nothing in this command: {kwargs["args"]}')
+            # Do nothing if cmd is empty
+            pass
+
+        anomlib.shell.runcmd(f"{command} {cmd}")
+        logging.debug(f'at-do: command: {command}  {cmd};')

anomlib/builtin/picload.py

@@ -0,0 +1,83 @@
+import hashlib, os, sys
+from pathlib import Path
+
+import anomlib.pillow
+
+home = Path.home()
+
+ggHome = home / "Pictures/gg"
+ggType = "jpeg"
+anomlib.pillow.mkdirs(str(ggHome))
+
+
+
+def num_to_index(start, stop, end, url_begin="", urlend=""):
+    fixture = len(str(end)) - len(str(start))
+    # Fix url_begin if the number's power is weak
+    url_begin += '0' * fixture
+    request = f'{url_begin}[{start}-{stop}]{urlend}'
+    return request
+
+
+def get_range(numbers, fixture):
+    fixture -= len(str(numbers[0])) - 1
+    patch = '0' * fixture
+    start = numbers[0]
+    stop = numbers[-1]
+    return start, stop
+
+def get_ranges(start, stop):
+    stop += 1
+    fixture = len(str(stop)) - len(str(start))
+    result = []
+    powers = {}
+    for i in [str(i) for i in range(start, stop)]:
+        if str(len(i)) not in powers:
+            powers[str(len(i))] = []
+        powers[str(len(i))] += [i]
+    for power, numbers in powers.items():
+        result += [get_range(numbers, fixture)]
+    return result
+        
+def curlRange(start, stop, url_begin="file_", urlend=".jpg"):
+    result = []
+    # stop += 1
+    for a, b in get_ranges(start, stop):
+        print ("a,b:", a, b)
+        result += [num_to_index(a, b, stop, url_begin, urlend)]
+    return result
+
+
+def getGallery(start, stop, url_begin="file_", urlend=".jpg",
+               ggHome=ggHome, ggType=ggType):
+    hash = anomlib.pillow.hashedString(url_begin + urlend)
+    print(hash)
+    requests = curlRange(start, stop, url_begin, urlend)
+    
+    ggDir = Path(ggHome) / hash
+    
+    # Do not proceed if dir alr exist
+    if os.path.isdir(ggDir):
+        print(f"The {hash} Files are already downloaded")
+        return
+    
+    # Fixme: Check that dir does not exist and then proceed
+    anomlib.pillow.mkdirs(str(ggDir))
+    
+    # Fixme: Change directory to current working directory
+    os.chdir(ggDir)
+
+    print(requests)
+    for request in requests:
+        print(f"curl '{request}' -o 'local2-#1.{ggType}'")
+        anomlib.shell.runcmd(f"curl {request} -o 'local-#1.{ggType}'")
+
+
+
+# print()
+# # print(getGallery(1, 900, "file", ".png"))
+# # print(getGallery(1, 90, "file-", ".jpeg"))
+# print(getGallery(1, 23, "https://image.hdporncomics.com/uploads/disguised-lust-0", ".jpg"))
+# # print(getGallery(1, 5, "https://image.hdporncomics.com/uploads/angel-x-stitch-00", ".jpg"))
+# # print(getGallery(1, 11, "https://im.hdporncomics.com/uploads/560facf644dc7837b5bd6f2a726c6582/she-s-not-little-anymore-0", ".jpg"))
+

anomlib/builtin/u2.py

@@ -0,0 +1,26 @@
+""" Y2 is a Youtube parser for fun.
+I will try to call invidious and/or youtube and play with their stuff they give me.
+The more info we reach the more stuff we can do with it.
+"""
+
+import requests
+from bs4 import BeautifulSoup
+
+# Fetch the page directly
+url = "https://www.youtube.com/playlist?list=PLRBp0Fe2Gpgn8Y9qI-p0aTxVtw8onBSFj"
+# url = "https://inv.nadeko.net/playlist?list=PLRBp0Fe2Gpgn8Y9qI-p0aTxVtw8onBSFj"
+html = requests.get(url).text
+
+# Parse the HTML with BeautifulSoup + lxml
+soup = BeautifulSoup(html, "lxml")
+
+# Extract the title and all links
+print(soup.title.get_text())
+
+for link in soup.select("a[href]"):
+    print(link["href"])
+
+
+# We will try different stratagies such us using different sites.
+# We will cache requests over to minimise the calls to google.
+

anomlib/builtin/youtube.py

@@ -0,0 +1,39 @@
+"Library wrapped around yt-dlp"
+
+from pathlib import Path
+import sys,os
+
+import anomlib.shell
+import anomlib.pillow
+
+
+# You can group videos by categories. e.g. Linux, NSFW, Memes, Movies, Music, How2 etc. 
+# by default videos are stored in Unknown group.
+# Feel free to move it into another group manually.
+group = "Unknown/%(channel_id)s"
+output = "%(title)s [%(id)s].%(ext)s".
+
+home = Path.home()
+
+# anomtool-youtube's home directory
+youtube = home / "Videos/Youtube/ytool"
+# Ytool is a command that is wrapped around anomtool-youtube builtin command
+videos = youtube / group
+
+video = videos / output
+
+## how to use manually:
+# >>> print(f"{dest}/{output}" % {'title': "a", 'id': "b", 'ext': "c"})
+# >>> str(video) % {'title':'video','id':'1','ext':'mp4'}
+# Note: check 'man yt-dlp' to know more about "available fields".
+
+pillow.mkdirs(videos)
+
+# Current youtube-dl tool
+yt_dl = "yt-dlp"
+
+def yt(args=[], options='--all-subs'):
+    f"{yt_dl} {options} -- {' '.join(args)}"
+
+yt(sys.argv[1:])
+

anomlib/commands/anomtool.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+# This file is part of 4g, the forge client.  (coding: utf-8)
+# License: GNU Lesser GPL version 3, see the file "AUTHORS" for details.
+
+# =====================
+# This file originally got inspiration from ranger's main python script.
+# ranger.py can be executed as python but also sourced in bash which is majestic.
+
+# =====================
+# This embedded bash script can be executed by sourcing this file.
+# It will cd to ranger's last location after you exit it.
+# The first argument specifies the command to run ranger, the
+# default is simply "ranger". (Not this file itself!)
+# The other arguments are passed to ranger.
+"""":
+anomtool="${1:-./4g}"
+if [ -n "$1" ]; then
+    shift
+fi
+"$anomtool" "${@:-$PWD}"
+return "$?"
+"""
+
+# import optparse
+# import subprocess
+# import textwrap
+# import argparse
+# import getopt
+# import logging
+
+import os
+import sys
+
+import anomlib.builtin.do
+import anomlib.builtin.picload
+import anomlib.pillow
+import anomlib.prmparser
+from anomlib.prmparser import ParamParser
+
+CONF = "params/anomtool.toml"
+CONF = os.path.abspath(CONF)
+print(CONF)
+
+# Fourgy's sub-Commands
+
+
+def anomtool_hash(p: ParamParser):
+    "main function of anomtool-hash"
+    name = p.options["all"]["source"]
+    hashTool = p.options["all"]["hash"]
+    for url in p.args["all"]:
+        print(anomlib.pillow.hashFourgySource(
+            url, name=name, hashTool=hashTool))
+
+
+def anomtool_do(p: ParamParser):
+    "main function for 4g do"
+
+    anomlib.builtin.do.do_repl(
+        args=p.args["all"],
+        history=p.options["all"]["history"],
+        readline=p.options["all"]["readline"],
+        prompt=p.options["all"]["prompt"],
+        color=p.options["all"]["color"])
+
+
+def anomtool_picload(p: ParamParser):
+    "main function for anomtool picload"
+
+    start = p.options["all"]["start"]
+    stop = p.options["all"]["stop"]
+    urlend = p.options["all"]["ending"]
+    ggType = p.options["all"]["type"]
+    p.options["all"]["home"] = os.path.expanduser(p.options["all"]["home"])
+    ggHome = p.options["all"]["home"]
+    for url_begin in p.args["all"]:
+        anomlib.builtin.picload.getGallery(
+            start, stop, url_begin, urlend,
+            ggType=ggType, ggHome=ggHome,
+        )
+        # # print(getGallery(1, 90, "file-", ".jpeg"))
+
+
+def main():
+    "Main function of anomtool command"
+    print(sys.argv[1:])
+    print(CONF)
+    p = ParamParser(toml=CONF)
+    return 0
+
+    # match p.command:
+    #     case "hash":
+    #         anomtool_hash(p)
+    #     case "picload":
+    #         anomtool_picload(p)
+    #     case "do":
+    #         anomtool_do(p)
+    #     # case "install":
+    #     #     anomtool.foGive.install()
+
+
+if __name__ == '__main__':
+    sys.exit(main())