'''

Create namespace convenience methods for all discovered ops.

Assumes we're running in an environment with scyjava configured to have a classpath with some SciJava Ops implementations (i.e. org.scijava:scijava-ops-engine plus implementations)

Classes:

OpNamespace

OpGateway

Variables:

env - OpEnvironment used to populate the OpGateway and OpNamespaces

ops - OpGateway entry point

'''

from scyjava import jimport

from types import MethodType

OpEnvironment = jimport('org.scijava.ops.api.OpEnvironment')

env = OpEnvironment.build()

op_names={str(name) for info in env.infos() for name in info.names()}

class OpNamespace:

'''

Represents intermediate ops categories. For example, "math.add" and "math.sub" are in both in the "math" namespace.

'''

def __init__(self, env, ns):

self.env = env

self.ns = ns

def help(self, op_name=None):

'''

Convenience wrapper for OpEnvironment.help(), for information about available ops. Prints all returned information, line-by-line.

'''

print(*self.env.help(op_name), sep = "\n")

class OpGateway(OpNamespace):

'''

Global base specialization of OpNamespace. Contains all other namespaces, in addition to all ops in the "global" namespace.

'''

def __init__(self, env):

super().__init__(env, 'global')

def nary(env, fqop, arity):

'''

Helper method to convert a numerical arity to the corresponding OpEnvironment method

Parameters:

env (OpEnvironment): the environment being used

fqop (str): the fully-qualified op name

arity (int): the desired arity of the op

Returns:

The appropriate OpBuilder.Arity instance for invoking the given op with the indicated number of parameters

'''

arities=[env.op, env.op, env.op, env.op, env.op, env.op, env.op, env.op, env.op, env.op, env.op, env.arity11, env.arity12, env.arity13, env.arity14, env.arity15, env.arity16]

return arities[arity](fqop)

def add_op(c, op_name):

'''

Helper method patch in a given op name as its corresponding function call within the given class

Parameters:

c (class): the OpNamespace/OpGateway to add a new function with the given op_name that calls the op

op_name (str): the actual name of the op we're adding

'''

if hasattr(c, op_name):

return

def f(self, *args, **kwargs):

'''

Instance method to attach to our OpNamespace/OpGateway that does the actual op call

'''

fqop = op_name if self.ns == 'global' else self.ns + "." + op_name

run = kwargs.get('run', True)

b = nary(self.env, fqop, len(args)).input(*args)

# inplace

# ops.filter.gauss(image, 5, inplace=0)

if (inplace:=kwargs.get('inplace', None)) is not None:

return b.mutate(inplace) if run else b.inplace(inplace)

# computer

# ops.filter.gauss(image, 5, out=result)

if (out:=kwargs.get('out', None)) is not None:

b=b.output(out)

return b.compute() if run else b.computer()

# function

# gauss_op = ops.filter.gauss(image, 5)

# result = ops.filter.gauss(image, 5)

return b.apply() if run else b.function()

if c == OpGateway:

# op_name is a global.

setattr(c, op_name, f)

else:

m=MethodType(f, c)

setattr(c, op_name, m)

def add_namespace(c, ns, op_name):

'''

Helper method to add an op call with nested OpNamespace instances if needed

Parameters:

c (class): the OpNamespace/OpGateway to add the given op and namespace

ns(str): the namespace to nest the given op within

op_name (str): the actual name of the op we're adding

'''

if not hasattr(c, ns):

setattr(c, ns, OpNamespace(env, ns))

add_op(getattr(c, ns), op_name)

# Entry point to do the namespace population.

# This modifies the OpGateway class to add a call for each op, with intermediate accessors by namespace

for op in op_names:

dot = op.find('.')

if dot >= 0:

ns=op[:dot]

op_name=op[dot+1:]

add_namespace(OpGateway, ns, op_name)

else:

add_op(OpGateway, op)

# Make an instance of our modified OpGateway class as a global for external use

ops = OpGateway(env)