OCM: Object Command Mapping

I often need to call command line software in Python scripts, usually through subprocess, for example:

import subprocess


subprocess.run(['ls','-l','/Users/dev'])

The following points of using subprocess make me feel inconvenient:

Need to determine the order of the parameters to determine the order of the list
No parameter verification
It is not convenient to get parameters, for example: ['ls','-l','/Users/dev'], I want to get the directory

In response to the above pain points, I implemented OCM. OCM is named after ORM. When we use Python for database query, we often need to do this:

cursor.execute('SELECT xxx FROM xxx WHERE xxx')
print(cursor.fetchone()[1])

Very inconvenient, you can use ORM to query like this:

xxx = XXX.objects.filter(xxx=xxx).first()
print(xxx.xxx)

So for OCM, what I want to achieve is to run a command like this:

ls = LsCommand(is_long=True, directory='.')
ls()

Installation

pip install python-ocm

Philosophy

Like click, OCM abstracts command-line parameters into two types:

Option, can be specified by -l, --long, -o foo.txt, etc.
Argument, can only pass the value directly, no key

For example: in ls -l /Users/dev:

-l is Option (here there is no value after -l, it is called flag)
/Users/dev is Argument

Usage

from ocm import Command, Option, Argument



class LS(Command):
    is_long = Option('-l', name='is_long', is_flag=True, required=False)
    directory = Argument(name='directory', required=True)

    class Meta:
        exe ='ls'


ls = LS(is_long=True, directory='/Users/dev')
print(ls.is_long)
print(ls.directory)
returncode, stdout = ls()
print(returncode)
print(stdout)

Parameter Type

OCM built-in parameter types:

StringParamType
IntegerParamType
FloatParamType
ChoicesParamType

Instructions:

from ocm import Command, Option, Argument, IntegerParamType


class Head(Command):
    number = Option('-n', name='number', param_type=IntegerParamType(), required=False)
    file = Argument(name='file')

    class Meta:
        exe ='head'


head = Head(number=10, file='ocm.py')
returncode, stdout = head()

Custom parameter type:

from ocm import ParamType


class MyParamType(ParamType):
    def convert(self, value, param, ctx):
        pass

    def show(self, value):
        pass

The convert method is responsible for converting the incoming data into the correct data:

value, the incoming data
param, the parameter object
ctx, all other incoming parameters

The show method is responsible for converting the data into a string to run on the command line:

value, the incoming data, generally the result of conversion by the convert method

Callback

The callback function can perform additional verification and conversion based on the data passed in by the user.

from ocm import Command, Option, Argument, IntegerParamType


def add_one(value, param, ctx):
    if value is None:
        return None
    return value + 1


class Head(Command):
    number = Option(
        '-n', name='number', param_type=IntegerParamType(), required=False, callback=add_one
    )
    file = Argument(name='file')

    class Meta:
        exe ='head'


head = Head(number=10, file='ocm.py')
returncode, stdout = head()

API

Option

__init__(self, key, is_flag=False, default=None, param_type=None, required=None, callback=None, multiple=False)

parameter:

key, the key of the Option when splicing into a command line, for example, -l
name, the name of the parameter
is_flag, whether this parameter is flag, see the description in the concept section, the default is False
default, the default value of the parameter
param_type, the type of the parameter, see the description of the parameter type
required, is it necessary?
callback, some parameters need to be converted according to the input value, you can customize the callback function, see the description of the callback function section
multiple, whether this parameter will be passed in multiple, for example, ls -l /Users/dev /Users/dev/Downloads/, directory parameter is passed twice
process_value(self, value, ctx)

Verify value according to the rules, and return the verified result:

value, the value to be verified
ctx, the value of other parameters passed in at the same time, used for the verification of the parameter

Argument

__init__(self, is_flag=False, default=None, param_type=None, required=None, callback=None, multiple=False)