Python TacticServerStub.query方法代码示例

# 需要导入模块: from tactic_client_lib import TacticServerStub [as 别名]
# 或者: from tactic_client_lib.TacticServerStub import query [as 别名]
    def _test_get_submission(self):

        server = TacticServerStub()
        server.set_project("sample3d")

        # choose some arbitrary bin
        bin_id = 4
        filters = []
        filters.append( ['bin_id', bin_id] )
        connectors = server.query("prod/submission_in_bin", filters)

        # get all of the submissions from the bin
        submission_ids = [x.get('submission_id') for x in connectors]
        filters = [ ['id', submission_ids] ]
        submissions = server.query("prod/submission", filters)


        # get all of the snapshots from the submissions
        for submission in submissions:
            search_key = submission.get('__search_key__')

            print "-"*20
            snapshot = server.get_snapshot(search_key, include_paths=True)

            paths = snapshot.get('__paths__')
            for path in paths:
                print path

# 需要导入模块: from tactic_client_lib import TacticServerStub [as 别名]
# 或者: from tactic_client_lib.TacticServerStub import query [as 别名]
def main():
    # get an instance of the stub
    server = TacticServerStub()

    # start the transaction
    server.start("Set query")
    try:

        # define the search type we are searching for
        search_type = "prod/asset"
          
        # define a filter
        filters = [] 
        filters.append( ("asset_library", "chr") )
          
        # do the query
        assets = server.query(search_type, filters)

        # show number found
        print("found [%s] assets" % len(assets) )
          
        # go through the asset and print the code
        for asset in assets:
            code = asset.get("code")  
            print(code)


    except:
        # in the case of an exception, abort all of the interactions
        server.abort()
        raise
    else:
        # otherwise, finish the transaction
        server.finish()

# 需要导入模块: from tactic_client_lib import TacticServerStub [as 别名]
# 或者: from tactic_client_lib.TacticServerStub import query [as 别名]
def main(args):
    # USAGE: query_shot.py <shot_code>
    shot_code = args[0]

    server = TacticServerStub()
    search_key = server.build_search_type(SEARCH_TYPE)

    # do the actual work
    server.start("Queried shot [%s]" % shot_code)
    try:
        filters = [
            ('code', shot_code)
        ]
        print server.query(search_key, filters)

    except:
        server.abort()
        raise
    else:
        server.finish()

# 需要导入模块: from tactic_client_lib import TacticServerStub [as 别名]
# 或者: from tactic_client_lib.TacticServerStub import query [as 别名]
def main(args):
    usage = "USAGE: checkin.py <search_type> <code> [context] <path>\n"
    usage += "example: python checkin.py beat Sc01.Bt01 .\\test\\image.png"

    context = "publish"

    # TODO: lots of assumptions here
    if len(args) == 2:
        # assume code and file path are equivalent
        code = args[1]
        file_path = args[1]
    elif len(args) == 3:
        code = args[1]
        file_path = args[2]
    elif len(args) == 4:
        code = args[1]
        context = args[2]
        file_path = args[3]
    else:
        print usage
        return

    search_type = args[0]

    server = TacticServerStub()

    # do the actual work
    server.start("Checked in file [%s] to [%s] - [%s]" % (file_path, search_type, code) )
    try:
        # query all of the search_types to simplify argument
        if search_type.find("/") == -1:
            columns = ["search_type"]
            results = server.query("sthpw/search_object", columns=columns)
            for result in results:
                test = result.get("search_type")
                if test.endswith("/%s" % search_type):
                    search_type = test
                    break
            else:
                raise Exception("Search type [%s] not found" % search_type)

        search_key = server.build_search_key(search_type, code)

        # upload the file
        server.upload_file(file_path)

        # checkin the uploaded file
        result = server.simple_checkin(search_key, context, file_path)
    except Exception, e:
        server.abort()
        print "ERROR: ", e.__str__()

# 需要导入模块: from tactic_client_lib import TacticServerStub [as 别名]
# 或者: from tactic_client_lib.TacticServerStub import query [as 别名]
def main(args, login=None):
    # USAGE: checkin_plates.py   
    code = args[0]
    file_range = args[1]
    pattern = args[2]
    # hard-coded for now
    context = 'publish'
    server = TacticServerStub(login)

    # do the actual work
    server.start("Checked in file group [%s]" % pattern)
    try:
        

        # checkin the uploaded file  
        filters = []
        filters.append(('code', code))
        results = server.query(SEARCH_TYPE, filters)
        # take the first one
        if results:
            id = results[0].get('id')
        else:
            print "Plate with code [%s] not found. Please insert an entry in the Plates tab first." %code
            return
        search_key = server.build_search_key(SEARCH_TYPE, id, column='id')


        # move the file
        dir = server.get_handoff_dir()
        print "Copied files to handoff dir\n"
        new_pattern = pattern
        file_type = 'main'
        
        # run group checkin
        server.group_checkin(search_key, context, file_path=new_pattern, file_type=file_type, \
                file_range=file_range, mode='copy', info={'type':'2d_plates'})
        
    except:
        server.abort()
        raise
    else:
        server.finish()

# 需要导入模块: from tactic_client_lib import TacticServerStub [as 别名]
# 或者: from tactic_client_lib.TacticServerStub import query [as 别名]
def main(args):

    search_type = args[0]
    code = args[1]
    if len(args) == 2:
        context = "publish"
        to_dir = "."
    elif len(args) == 3:
        context = "publish"
        to_dir = args[2]
    else:
        context = args[2]
        to_dir = args[3]

    server = TacticServerStub()

    # do the actual work
    server.start("Checked out file/s to [%s]" % to_dir)
    try:
        # query all of the search_types to simplify argument
        if search_type.find("/") == -1:
            columns = ["search_type"]
            results = server.query("sthpw/search_object", columns=columns)
            for result in results:
                test = result.get("search_type")
                if test.endswith("/%s" % search_type):
                    search_type = test
                    break
            else:
                raise Exception("Search type [%s] not found" % search_type)

        search_key = server.build_search_key(search_type, code)

        # checkin the uploaded file
        version = -1
        result = server.checkout(search_key, context, version=version, to_dir=to_dir)
        print result
    except:
        server.abort()
        raise
    else:
        server.finish()

# 需要导入模块: from tactic_client_lib import TacticServerStub [as 别名]
# 或者: from tactic_client_lib.TacticServerStub import query [as 别名]
def main(args, login=None):
    # USAGE: checkin_render.py   
    type = args[0]
    if type == "shot":
        parent_search_type = "prod/shot"
    elif type == "asset":
        parent_search_type = "prod/asset"
    

    else:
        parent_search_type = type

    code = args[1]
    file_range = args[2]
    pattern = args[3]
    layer_name = ''
    context = 'publish'

    if type == "layer":
        parent_search_type = "prod/layer"
        code, layer_name = args[1].split('|')
        
    server = TacticServerStub(login)

    # do the actual work
    server.start("Checked in file group [%s] to %s [%s]" % (pattern,type,code))

    try:
        # checkin the uploaded file  
        filters = []
        if type=='layer':
            filters.append(('shot_code', code))
            filters.append(('name', layer_name))
        else:
            filters.append(('code', code))
        results = server.query(parent_search_type, filters)
       
        # take the first one
        if results:
            id = results[0].get('id')
        else:
            if type =='layer':
                print "%s Code [%s] name [%s] not found. Please insert an entry in TACTIC first." %(type, code, layer_name)
            else:
                print "%s Code [%s] not found. Please insert an entry in TACTIC first." %(type, code)
        search_type = server.build_search_type(parent_search_type)
        file_type = 'main'
        render_type = '' # not used yet
        # move the file
        dir = server.get_handoff_dir()
        paths = expand_paths(pattern, file_range)
        copy_file(paths, dir)

        file_name = os.path.basename(pattern)
        new_pattern =  '%s/%s' %(dir, file_name)
        print "Copied files to handoff dir\n"
        render = find_render(server, search_type, id, login, render_type)
        if not render:
            render_data = {
                'search_type': search_type,
                'search_id': id,
                'login': login
                #'type': render_type
            }
            render = server.insert("prod/render", render_data)
        
        # run group checkin
        server.group_checkin(render.get("__search_key__"), context=context, file_path=new_pattern, file_type=file_type, file_range=file_range)
        
    except:
        server.abort()
        raise
    else:
        server.finish()

# 需要导入模块: from tactic_client_lib import TacticServerStub [as 别名]
# 或者: from tactic_client_lib.TacticServerStub import query [as 别名]
class Sample3dTest(unittest.TestCase):

    def setUp(self):
        pass

    def test_all(self):
        print "Running Sample3d Test"

        from pyasm.security import Batch
        from pyasm.biz import Project
        Batch()
        Project.set_project("sample3d")


        #self.server = TacticServerStub(protocol="local")
        self.server = TacticServerStub(protocol="xmlrpc")
        project_code = "sample3d"
        self.server.set_project(project_code)


        self.server.start("Sample3d Test")
        try:
            self._test_create_search_type()
            self._test_create_submission()
            self._test_get_submission()
            self._test_shot_sequence_hierarchy()
            self._test_query_snapshots()
            #self._test_performance()
        except Exception:
            self.server.abort()
            raise
        self.server.abort()


        #try:
        #    self.server.query("prod/asset")
        #except Exception:
        #    self.server.abort()
        #    raise
        #self.server.abort()



    def _test_query_snapshots(self):
        filters = []
        filters.append( ['context', 'model'] )
        filters.append( ['search_type', 'prod/asset?project=sample3d'] )
        snapshots = self.server.query_snapshots(filters=filters, include_paths=True)

        import time
        start = time.time()
        for snapshot in snapshots:
            print snapshot.get('__search_key__')
            print snapshot.get('__paths__')
            print "parent: ", snapshot.get('__parent__')
        print time.time() - start




    def _test_create_search_type(self):
        search_type = 'test'
        search_type_obj = self.server.create_search_type(search_type)
        print search_type_obj




    def _test_performance(self):

        for i in range(0,1):
            assets = self.server.query("prod/asset")
            for asset in assets:
                asset_key = asset.get("__search_key__")
                snapshots = self.server.get_all_children(asset_key,'sthpw/snapshot')
                #snapshot = self.server.get_snapshot(asset_key,context='model', include_paths=True)
                #print snapshot.get('__paths__')


        




    def _test_get_submission(self):

        server = TacticServerStub()
        server.set_project("sample3d")

        # choose some arbitrary bin
        bin_id = 4
        filters = []
        filters.append( ['bin_id', bin_id] )
        connectors = server.query("prod/submission_in_bin", filters)

        # get all of the submissions from the bin
        submission_ids = [x.get('submission_id') for x in connectors]
        filters = [ ['id', submission_ids] ]
        submissions = server.query("prod/submission", filters)

#.........这里部分代码省略.........

# 需要导入模块: from tactic_client_lib import TacticServerStub [as 别名]
# 或者: from tactic_client_lib.TacticServerStub import query [as 别名]
def main(args, login=None):
    # USAGE: checkin_render_layer.py
    shot_code = args[0]
    layer_name = args[1]
    version = args[2]
    context = args[3]
    file_range = args[4]
    pattern = args[5]

    server = TacticServerStub(login)

    # do the actual work
    server.start("Checked in file group [%s] to shot [%s] layer [%s]" % (pattern, shot_code, layer_name))
    try:
        # move the file
        dir = server.get_handoff_dir()
        paths = expand_paths(pattern, file_range)
        move_file(paths, dir)

        file_name = os.path.basename(pattern)
        new_pattern = "%s/%s" % (dir, file_name)
        print "Files moved to handoff dir.\n"

        # checkin the moved files
        filters = []
        filters.append(("shot_code", shot_code))
        filters.append(("name", layer_name))
        results = server.query("prod/layer", filters)

        # take the first one
        if results:
            id = results[0].get("id")

        search_type = server.build_search_type("prod/layer")
        # find the layer snapshot
        filters = []
        filters.append(("version", version))
        filters.append(("search_type", search_type))
        filters.append(("search_id", id))
        # TODO : may need a context to search for the proper layer
        results = server.query("sthpw/snapshot", filters)
        snap_code = ""
        if results:
            snap_code = results[0].get("code")

        # find the render
        render = None
        filters = []
        filters.append(("search_type", search_type))
        filters.append(("search_id", id))
        filters.append(("snapshot_code", snap_code))
        results = server.query(SEARCH_TYPE, filters)
        if results:
            render = results[0]

        if not render:
            render_data = {"search_type": search_type, "search_id": id, "snapshot_code": snap_code}

            render = server.insert("prod/render", render_data)
        """
        results = server.query(SEARCH_TYPE, filters)
        render_id = 0
        if results:
            render_id = results[0].get('id')
        # find the render id    
        search_key = server.build_search_key(SEARCH_TYPE, render_id, column='id')
        """
        file_type = "main"

        # run group checkin
        server.group_checkin(
            render.get("__search_key__"),
            context=context,
            file_path=new_pattern,
            file_type=file_type,
            file_range=file_range,
        )

    except:
        server.abort()
        raise
    else:
        server.finish()