def __init__(self):
from auto_everything.io import IO
from auto_everything.base import OS
from auto_everything.terminal import Terminal
from auto_everything.disk import Disk
self._io = IO()
self._os = OS()
self._t = Terminal()
self._disk = Disk()
class Python():
"""
Python model was intended to simplify python development
"""
def __init__(self):
from auto_everything.io import IO
from auto_everything.base import OS
from auto_everything.terminal import Terminal
from auto_everything.disk import Disk
self._io = IO()
self._os = OS()
self._t = Terminal()
self._disk = Disk()
def list_python_packages(self):
"""
Return a list of python packages which installed in your computer
"""
return self._os.list_python_packages()
def install_package(self, package_name):
"""
Parameters
----------
package_name: string
the python package you want to install
"""
self._os.install_python_package(package_name)
def uninstall_package(self, package_name):
"""
Parameters
----------
package_name: string
the python package you want to uninstall
"""
self._os.uninstall_python_package(package_name)
class loop():
def __init__(self, interval=1, thread=False):
"""
new_thread: do you want to open a new thread? True/False
"""
self.thread = thread
self.interval = interval
def __call__(self, func):
"""
func: a function which you want to run forever
"""
def new_function(*args, **kwargs):
def while_function():
while 1:
try:
func(*args, **kwargs)
time.sleep(self.interval)
except Exception as e:
print(e)
if self.thread is False:
while_function()
else:
threading.Thread(target=while_function).start()
return new_function
def help(self, object_):
"""
get help information about class or function
"""
from inspect import signature
if callable(object_):
arguments = str(signature(object_))
print(object_.__name__ + arguments)
doc = object_.__doc__
if doc:
print(doc, '\n')
else:
methods = dir(object_)
private_methods = []
public_methods = []
for method in methods:
if method[:1] == "_":
private_methods.append(method)
else:
public_methods.append(method)
print(private_methods, '\n')
pprint(public_methods)
"""
callable_list = inspect.getmembers(object_, predicate=inspect.ismethod) + inspect.getmembers(object_,
predicate=inspect.isclass)
callable_list = [(one, one[1].__name__ + str(signature(one[1]))) for one in callable_list]
not_callable_list = dir(object_)
for one in callable_list:
if one[0] in not_callable_list:
not_callable_list.remove(one[0])
not_callable_list = [(one, "") for one in not_callable_list]
private_methods = []
public_methods = []
for one in not_callable_list + callable_list:
if one[0][:1] == "_":
private_methods.append(one[0])
else:
public_methods.append(one)
print(private_methods, "\n")
[print(one[0], one[1]) for one in public_methods]
"""
def fire(self, class_name):
"""
fire is a function that will turn any Python class into a command line interface
"""
from fire import Fire
Fire(class_name)
def make_it_runnable(self, py_file_path=None):
"""
make python file runnable
after use this function, you can run the py_file by: ./your_py_script_name.py
"""
if py_file_path is None or self._t.exists(py_file_path):
py_file_path = os.path.join(self._t.current_dir,
sys.argv[0].strip('./'))
if os.path.exists(py_file_path):
codes = self._io.read(py_file_path)
expected_first_line = '#!/usr/bin/env {}'.format(
self._t.py_executable)
if codes.split('\n')[0] != expected_first_line:
codes = expected_first_line + '\n' + codes
self._io.write(py_file_path, codes)
self._t.run_command('chmod +x {}'.format(py_file_path))
if not self._disk.executable(py_file_path):
self._t.run_command('chmod +x {}'.format(py_file_path))
def make_it_global_runnable(self, py_file_path=None, executable_name=None):
"""
make python file global runnable
after use this function, you can run the py_file at anywhere by: your_py_script_name.py
"""
self.make_it_runnable(py_file_path)
auto_everything_config_folder = "~/.auto_everything"
bin_folder = os.path.expanduser(
os.path.join(auto_everything_config_folder, "bin"))
if not self._t.exists(bin_folder):
self._t.run_command(f"mkdir -p {bin_folder}")
if py_file_path is None or not self._t.exists(py_file_path):
py_file_path = os.path.join(self._t.current_dir,
sys.argv[0].strip('./'))
is_the_first_running = False
runnable_path = None
if os.path.exists(py_file_path):
if executable_name == None:
_, executable_name = os.path.split(py_file_path)
runnable_path = os.path.join(bin_folder, executable_name)
if not os.path.exists(runnable_path):
is_the_first_running = True
# remove links that the real file has been moved, or, remove links that match this py_file_path but with a different executable name
files = os.listdir(bin_folder)
[
self._t.run(f"cd {bin_folder}; rm {file}") for file in files
if not os.path.exists(os.path.join(bin_folder, file))
]
files = self._disk.get_files(bin_folder, recursive=False)
[
self._t.run(f"rm {file}") for file in files
if os.path.realpath(file) == py_file_path
and file != runnable_path
]
self._t.run_command(f"ln -s {py_file_path} {runnable_path}")
bashrc_path = self._t.fix_path(f"~/.bashrc")
bashrc_target_line = f'export PATH="$PATH:{bin_folder}"'
bashrc = self._io.read(bashrc_path)
if bashrc_target_line not in bashrc.split("\n"):
bashrc = bashrc + "\n" + bashrc_target_line
self._t.run_command(f"touch {bashrc_path}")
self._io.write(bashrc_path, bashrc)
if is_the_first_running and runnable_path:
print(
f"\n\n------------------\n\nYou could run \n\n{runnable_path.split('/')[-1]} -- --completion\n\nto get bash completion scripts"
)
def print(self, data, limit=20):
"""
print `function help info` or print `dict` with length limit (So you could see the structure easily)
"""
if callable(data):
self.help(data)
else:
data = copy.deepcopy(data)
def infinite_loop(the_data):
the_type = type(the_data)
if the_type == str:
return the_data[:limit] + "..."
elif the_type == dict:
for key, value in the_data.items():
the_data[key] = infinite_loop(value)
return the_data
elif the_type == list:
return [infinite_loop(element) for element in the_data]
else:
return the_data
data = infinite_loop(data)
pprint(data)
try:
from .rpc import server_pb2, server_pb2_grpc
except Exception as e:
print(e)
from rpc import server_pb2, server_pb2_grpc
import grpc
import easyocr
import json
import numpy as np
from time import sleep
from pdf2image import convert_from_path
from auto_everything.disk import Disk
from auto_everything.base import Terminal
disk = Disk()
t = Terminal()
server = None
def convert(o):
if isinstance(o, np.int64):
return int(o)
raise TypeError
class OCR():
def __init__(self):
self.reader = None
#!/usr/bin/env /usr/bin/python3
from auto_everything.terminal import Terminal
from auto_everything.disk import Disk
from auto_everything.base import IO
from auto_everything.base import Python
import json
t = Terminal()
disk = Disk()
io = IO()
py = Python()
def seperate():
print()
print("-------")
print()
DEVICE = "/dev/ttyUSB0"
PRE_COMMAND = f"ampy -p {DEVICE} "
LS = PRE_COMMAND + "ls"
DELETE = PRE_COMMAND + "rm "
PUT = PRE_COMMAND + "put "
micropython_files = [
name.strip("/") for name in t.run_command(LS).split("\n")
if name.strip() != "" and name[-3:] == ".py"
]
print(micropython_files)
if len(micropython_files) == 0:
exit()