Merge pull request #1 from codesrg/develop

Add files via upload

Author: codesrg

README.md

@@ -0,0 +1,68 @@
+# IOutil
+
+[![PyPI](https://img.shields.io/pypi/v/ioutil)](https://pypi.python.org/pypi/ioutil)
+[![Pypi - License](https://img.shields.io/github/license/codesrg/ioutil)](https://github.com/codesrg/ioutil/blob/main/LICENSE)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ioutil?color=red)](https://pypi.python.org/pypi/ioutil)
+
+To read and write files.
+
+csv, json, parquet, text, toml formats is supported.
+
+## Installation
+
+`pip install -U ioutil`
+
+## Usage
+
+```
+usage: ioutil [options]
+
+optional arguments:
+  -h, --help      show this help message and exit
+  -v, --version   show version number and exit.
+
+to read/write files:
+  path            path to read/write
+  -r, --read      to read file
+  -w, --write     to write file
+  -d, --data      data to write
+  -f, --format    file format to use
+  -m, --mode      mode to open file
+  --rfv           will return formatted string (CSV only)
+```
+
+### Python Script
+
+To encrypt/decrypt message using rsa.
+
+```python
+from ioutil import csv
+
+data = [['a', 'b'], [[1, 2], [3, 4]]]
+path = '.../file.csv'
+csv.write(data, path)  # to write csv
+csv.read(path)  # to read csv
+```
+
+### Command Line
+
+To write a text file.
+
+```
+$ ioutil ".../file.txt" --data "data" --write
+True
+```
+
+###
+
+To read a json file.
+
+```
+$ ioutil ".../file.json" --read
+### content of a file ###
+```
+
+## Issues:
+
+If you encounter any problems, please file an [issue](https://github.com/codesrg/ioutil/issues) along with a detailed
+description.

ioutil/__init__.py

@@ -0,0 +1,38 @@
+"""to read and write files"""
+
+from typing import Literal
+
+from ioutil._file import _File
+from ioutil._csv import Csv
+from ioutil._text import Text
+from ioutil._toml import TOML
+from ioutil._json import Json
+from ioutil._parquet import Parquet
+
+
+class File:
+    @staticmethod
+    def getinstance(_format: Literal["csv", "json", "parquet", "toml", "text"]) -> _File:
+        _instance = {"csv": Csv, "json": Json, "parquet": Parquet, "toml": TOML, "text": Text}.get(_format)
+        if not _instance:
+            _instance = _File
+        return _instance()
+
+
+csv = Csv()
+json = Json()
+parquet = Parquet()
+text = Text()
+toml = TOML()
+
+__author__ = 'srg'
+__version__ = '1.0.0'
+
+__all__ = [
+    'File',
+    'csv',
+    'json',
+    'parquet',
+    'toml',
+    'text'
+]

ioutil/__main__.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import os
+import sys
+import argparse
+from srutil import util
+from typing import AnyStr
+
+from . import File, __version__, __package__, __all__
+from ._file import _File
+
+
+def get_argument():
+    parser = argparse.ArgumentParser(prog=__package__, usage=util.stringbuilder(__package__, " [options]"))
+    parser.add_argument('-v', '--version', action='version', help='show version number and exit.', version=__version__)
+    group = parser.add_argument_group("to read/write files")
+    group.add_argument("path", type=str, help="path to read/write")
+    group.add_argument("-r", "--read", dest="read", default=False, action="store_true", help="to read file")
+    group.add_argument("-w", "--write", dest="write", default=False, action="store_true", help="to write file")
+    group.add_argument("-d", "--data", metavar='', help="data to write")
+    group.add_argument("-f", "--format", dest='format', metavar='', choices=['csv', 'json', 'parquet', 'text', 'toml'],
+                       type=str, required=False, help="file format to use")
+    group.add_argument("-m", "--mode", dest="mode", metavar='', default=None, help="mode to open file")
+    group.add_argument("--rfv", dest="rfv", default=False, action="store_true",
+                       help="will return formatted string (CSV only)")
+    parser.add_argument_group(group)
+    options = parser.parse_args()
+    if not options.format:
+        _format = list(os.path.splitext(options.path)).pop().lstrip('.')
+        if _format != 'File' and _format not in __all__:
+            parser.error("the following arguments are required: -f/--format")
+        else:
+            options.format = _format
+    if not options.read and not options.write:
+        parser.error("one of the following arguments are required: -r/--read or -w/--write")
+    if options.read and options.write:
+        parser.error("any one of the following arguments should be given: -r/--read or -w/--write")
+    if options.write and not options.data:
+        parser.error("the following arguments are required: -d/--data")
+    return options
+
+
+def _remove_unwanted_params(f: _File, params: dict) -> dict:
+    method_list = {'read': f.read, 'write': f.write}
+    params_of_method = util.paramsofmethod(method_list.get(util.whocalledme())).keys()
+    new_params = dict()
+    for key, value in params.items():
+        if key in params_of_method:
+            new_params.setdefault(key, value)
+    return new_params
+
+
+def read(f: _File, path: AnyStr | os.PathLike, **kwargs):
+    kwargs = _remove_unwanted_params(f, kwargs)
+    data = f.read(path=path, **kwargs)
+    print(data)
+
+
+def write(f: _File, data, path: AnyStr | os.PathLike, **kwargs):
+    kwargs = _remove_unwanted_params(f, kwargs)
+    status = f.write(data=data, path=path, **kwargs)
+    print(status)
+
+
+def main():
+    options = get_argument()
+    f = File.getinstance(options.format)
+    mode = options.mode if options.mode else 'w' if options.write else 'r'
+    if options.read:
+        read(f, options.path, mode=mode, _rfv=options.rfv)
+    elif options.write:
+        write(f, options.data, options.path, mode=mode)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ioutil/_csv.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+import os
+import csv
+from srutil import util
+from typing import AnyStr, Dict, List
+
+from ._file import _File
+
+
+class Csv(_File):
+
+    def write(self, data: List[List, List[Dict | List]], path: AnyStr | os.PathLike[AnyStr], mode: str = 'w') -> bool:
+        fields = data.__getitem__(0)
+        rows = data.__getitem__(1)
+        with self._get_stream(path, mode) as csvfile:
+            if isinstance(rows.__getitem__(0), list):
+                csvwriter = csv.writer(csvfile)
+                csvwriter.writerow(fields)
+                csvwriter.writerows(rows)
+            elif isinstance(rows.__getitem__(0), dict):
+                csvwriter = csv.DictWriter(csvfile, fieldnames=fields)
+                csvwriter.writeheader()
+                csvwriter.writerows(rows)
+        return os.path.exists(path)
+
+    def read(self, path: AnyStr | os.PathLike[AnyStr], mode: str = 'r', _rfv: bool = False) -> List[List] | str:
+        """
+        :param path: path to target file
+        :param mode: reading mode
+        :param _rfv: True will return formatted string
+        :return: list of values or formatted string
+        """
+        to_return = list()
+        with self._get_stream(path, mode) as csvfile:
+            for line in csv.reader(csvfile):
+                to_return.append(line)
+        return util.tabulate(to_return) if _rfv else to_return

ioutil/_file.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import abc
+import os
+from srutil import util
+from typing import AnyStr
+
+meta_interface = util.metaclass('interface')
+
+
+class IOInterface(metaclass=meta_interface):
+
+    def write(self, data: AnyStr, path: AnyStr | os.PathLike[AnyStr], **kwargs) -> bool:
+        pass
+
+    def read(self, path: AnyStr | os.PathLike[AnyStr], **kwargs):
+        pass
+
+
+class _File:
+    @staticmethod
+    def _get_stream(file: AnyStr | os.PathLike[AnyStr], mode: str):
+        return open(file, mode)
+
+    @abc.abstractmethod
+    def write(self, **kwargs) -> bool:
+        pass
+
+    @abc.abstractmethod
+    def read(self, **kwargs):
+        pass

ioutil/_json.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import AnyStr
+
+from ._file import _File
+
+
+class Json(_File):
+
+    def write(self, data: str | dict, path: AnyStr | os.PathLike[AnyStr], mode: str = 'w') -> bool:
+        _json_obj = json.dumps(data)
+        with self._get_stream(path, mode) as jsonfile:
+            json.dump(_json_obj, jsonfile)
+        return os.path.exists(path)
+
+    def read(self, path: AnyStr | os.PathLike[AnyStr], mode: str = 'r') -> dict:
+        """
+        :param path: path to target json file
+        :param mode: reading mode
+        :return: dict values
+        """
+        with self._get_stream(path, mode) as jsonfile:
+            return json.load(jsonfile)

ioutil/_parquet.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import os
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+from typing import AnyStr
+
+from ._file import _File
+
+
+class Parquet(_File):
+
+    def write(self, data: dict, path: AnyStr | os.PathLike[AnyStr]) -> bool:
+        dataframe = pd.DataFrame.from_dict(data)
+        table = pa.Table.from_pandas(df=dataframe)
+        pq.write_table(table, path)
+        return os.path.exists(path)
+
+    def read(self, path: AnyStr | os.PathLike[AnyStr]) -> pd.DataFrame | pd.Series:
+        """
+        :param path: path to target parquet file
+        :return: pandas dataframe
+        """
+        table = pq.read_table(path)
+        return table.to_pandas()

ioutil/_text.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import os
+from typing import AnyStr
+
+from ._file import _File
+
+
+class Text(_File):
+
+    def write(self, data: AnyStr, path: AnyStr | os.PathLike[AnyStr], mode: str = 'w') -> bool:
+        with self._get_stream(path, mode) as textfile:
+            textfile.write(data)
+        return os.path.exists(path)
+
+    def read(self, path: AnyStr | os.PathLike[AnyStr], mode: str = 'r') -> AnyStr:
+        """
+        :param path: path to target file
+        :param mode: reading mode
+        :return: string or bytes
+        """
+        with self._get_stream(path, mode) as textfile:
+            return textfile.read()

ioutil/_toml.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import os
+import toml
+from typing import AnyStr, Any, Mapping
+
+from ._file import _File
+
+
+class TOML(_File):
+
+    def write(self, data: Mapping[str, Any], path: AnyStr | os.PathLike[AnyStr], mode: str = 'w') -> bool:
+        with self._get_stream(path, mode) as toml_file:
+            toml.dump(data, toml_file)
+        return os.path.exists(path)
+
+    def read(self, path: AnyStr | os.PathLike[AnyStr], mode: str = 'r') -> dict[str, Any]:
+        """
+        :param path: path to target json file
+        :param mode: reading mode
+        :return: dict values
+        """
+        with self._get_stream(path, mode) as toml_file:
+            return toml.load(toml_file)

pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=42"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ioutil"
+version = "1.0.0"
+description = "To read and write files."
+readme = "README.md"
+requires-python = ">=3.6"
+license = { text = "Apache License, Version 2.0" }
+authors = [
+    { name = "srg", email = "[email protected]" },
+]
+dependencies = [
+    "toml",
+    "srutil",
+    "pandas",
+    "pyarrow"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+]
+keywords = [
+    "io", "read", "write", "file", "ioutil"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/codesrg/ioutil"
+"Bug Tracker" = "https://github.com/codesrg/ioutil/issues"
+
+[project.scripts]
+ioutil = "ioutil.__main__:main"