clams-python 1.2.1__tar.gz → 1.2.3__tar.gz

{clams_python-1.2.1/clams_python.egg-info → clams_python-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clams-python
-Version: 1.2.1
+Version: 1.2.3
 Summary: A collection of APIs to develop CLAMS app for python
 Home-page: https://clams.ai
 Author: Brandeis Lab for Linguistics and Computation
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mmif-python==1.0.13
+Requires-Dist: mmif-python==1.0.15
 Requires-Dist: Flask>=2
 Requires-Dist: Flask-RESTful>=0.3.9
 Requires-Dist: gunicorn>=20

clams_python-1.2.3/VERSION

@@ -0,0 +1 @@
+1.2.3

{clams_python-1.2.1 → clams_python-1.2.3}/clams/app/__init__.py

@@ -20,6 +20,16 @@ logging.basicConfig(
     datefmt="%Y-%m-%d %H:%M:%S")
 
 
+falsy_values = [
+    'False', 
+    'false', 
+    'F',
+    'f',
+    '0',
+    0, 
+    False
+]
+
 class ClamsApp(ABC):
     """
     An abstract class to define API's for ClamsApps. A CLAMS app should inherit
@@ -178,7 +188,14 @@ class ClamsApp(ABC):
                     raise ValueError(f"Value for parameter \"{parameter.name}\" must be one of {parameter.choices}.")
                 refined[parameter.name] = casted[parameter.name]
             elif parameter.default is not None:
-                refined[parameter.name] = parameter.default
+                # have to cast the default values as well, since 
+                # 1. `map` type default values are not actually expected as a map (dict)
+                # 2. developers can use data type not matching the spec
+                if isinstance(parameter.default, list):
+                    casted_default = self.annotate_param_caster.cast({parameter.name: list(map(str, parameter.default))})
+                else:
+                    casted_default = self.annotate_param_caster.cast({parameter.name: [str(parameter.default)]})
+                refined.update(casted_default)
             else:
                 raise ValueError(f"Cannot find configuration for a required parameter \"{parameter.name}\".")
         # raw input params are hidden under a special key
@@ -338,8 +355,8 @@ class ParameterCaster(object):
             assert isinstance(vs, list), f"Expected a list of values for key {k}, but got {vs} of type {type(vs)}"
             assert all(isinstance(v, str) for v in vs), f"Expected a list of strings for key {k}, but got {vs} of types {[type(v) for v in vs]}"
             if k in self.param_spec:
+                valuetype, multivalued = self.param_spec[k]
                 for v in vs:
-                    valuetype, multivalued = self.param_spec[k]
                     if multivalued or k not in casted:  # effectively only keeps the first value for non-multi params
                         if valuetype == bool:
                             v = self.bool_param(v)
@@ -358,11 +375,22 @@ class ParameterCaster(object):
                                 casted.setdefault(k, []).append(v)
                         else: 
                             casted[k] = v
+                # when an empty value is passed (usually as a default value)
+                # just add an empty list or dict as a placeholder
+                # explicit check for `len == 0` is required to prevent 
+                # empty values are set for params that don't have default values
+                if multivalued and len(vs) == 0:
+                    if valuetype == dict:
+                        casted.setdefault(k, {})
+                    else:
+                        casted.setdefault(k, [])
             else:
-                if len(vs) > 1:
-                    casted[k] = vs
-                else:
+                # if the parameter is not defined in the spec, there's no easy way to figure out 
+                # the user's intention whether it should be a list (multivalued) or a single value.
+                if len(vs) == 1:
                     casted[k] = vs[0]
+                else:
+                    casted[k] = vs
         return casted  # pytype: disable=bad-return-type
 
     @staticmethod
@@ -370,7 +398,7 @@ class ParameterCaster(object):
         """
         Helper function to convert string values to bool type.
         """
-        return False if value in (False, 0, 'False', 'false', '0') else True
+        return False if value in falsy_values else True
 
     @staticmethod
     def float_param(value) -> float:

{clams_python-1.2.1 → clams_python-1.2.3}/clams/appmetadata/__init__.py

@@ -162,7 +162,8 @@ class RuntimeParameter(_BaseModel):
     type: param_value_types = pydantic.Field(
         ...,
         description=f"Type of the parameter value the app expects. Must be one of {param_value_types_values}. When "
-                    "type is ``map``, ``multivalued=true`` is automatically forced. \n\n"
+                    "type is ``map``, ``multivalued=true`` is forced, and when ``boolean``, ``multivalued=false`` is "
+                    "forced. \n\n"
                     "Notes for developers: \n\n"
                     "When the type is ``map``, the parameter value (still a single string from the users' perspective) "
                     "must be formatted as a ``KEY:VALUE`` pair, namely a colon-separated string. To pass multiple "
@@ -186,7 +187,7 @@ class RuntimeParameter(_BaseModel):
         description="(optional) Default value for the parameter.\n\n"
                     "Notes for developers: \n\n"
                     "Setting a default value makes a parameter `optional`. \n\n"
-                    "When ``multivalued=True``, the default value should be a list of values. \n\n"
+                    "When ``multivalued=true``, the default value should be a list of values. \n\n"
                     "When ``type=map``, the default value should be a list of colon-separated strings. \n\n"
     )
     multivalued: bool = pydantic.Field(
@@ -420,8 +421,10 @@ class AppMetadata(pydantic.BaseModel):
         # see https://docs.pydantic.dev/1.10/usage/types/#unions
         # e.g. casting 0.1 using the `primitives` dict will result in  0 (int)
         # while casting "0.1" using the `primitives` dict will result in  0.1 (float)
-        if type == 'map' and multivalued is False:
+        if type == 'map':
             multivalued = True
+        if type == 'boolean':
+            multivalued = False
         if default is not None:
             if isinstance(default, list):
                 default = [str(d) for d in default]

{clams_python-1.2.1 → clams_python-1.2.3}/clams/develop/__init__.py

@@ -7,6 +7,7 @@ from typing import List
 
 import clams
 
+update_tmp_suffix = '.tmp'
 available_recipes = {
     'app': {
         'description': 'Skeleton code for a CLAMS app',
@@ -26,7 +27,7 @@ class CookieCutter(object):
     def __init__(self, name: str, outdir: str, recipes: List[str]):
         self.rawname = name 
         self.name_tokens = self.tokenize_rawname()
-        self.ourdir = pathlib.Path(outdir)
+        self.outdir = pathlib.Path(outdir)
         if recipes:
             self.recipes = recipes
         else:
@@ -42,24 +43,30 @@ class CookieCutter(object):
                 words.pop()
         return words
     
-    def bake(self):
+    def bake(self, update_level=0):
         print(f"Baking {self.recipes}")
         for recipe in self.recipes:
             src_dir = pathlib.Path(__file__).parent / 'templates' / available_recipes[recipe]['sourcedir']
-            dst_dir = self.ourdir / self.rawname / available_recipes[recipe]['targetdir']
+            dst_dir = self.outdir / self.rawname / available_recipes[recipe]['targetdir']
             if recipe == 'app':
-                self.bake_app(src_dir, dst_dir)
+                caps = [t.capitalize() for t in self.name_tokens]
+                app_vars = {
+                    'CLAMS_VERSION': clams.__version__,
+                    'APP_CLASS_NAME': "".join(caps),
+                    'APP_NAME': " ".join(caps),
+                    'APP_IDENTIFIER': '-'.join(self.name_tokens)
+                }
+                if update_level > 0:
+                    self.reheat_app(src_dir, dst_dir, app_vars, reheat_level=update_level)
+                else:
+                    if dst_dir.exists():
+                        raise FileExistsError(f"  {dst_dir} already exists. Did you mean `--update`? ")
+                    self.bake_app(src_dir, dst_dir, app_vars)
             if recipe == 'gha':
+                # There's nothing for devs to tweak GHA template, so first generation and updating are the same.
                 self.bake_gha(src_dir, dst_dir)
             
-    def bake_app(self, src_dir, dst_dir):
-        caps = [t.capitalize() for t in self.name_tokens]
-        templating_vars = {
-            'CLAMS_VERSION': clams.__version__,
-            'APP_CLASS_NAME': "".join(caps),
-            'APP_NAME': " ".join(caps),
-            'APP_IDENTIFIER': '-'.join(self.name_tokens)
-        }
+    def bake_app(self, src_dir, dst_dir, templating_vars):
         for g in src_dir.glob("**/*.template"):
             r = g.relative_to(src_dir).parent
             f = g.with_suffix('').name
@@ -71,7 +78,40 @@ class CookieCutter(object):
                 out_f.write(compiled)
         print(f"App skeleton code is copied to {self.rawname}")
         print(f"  Checkout {self.rawname}/README.md for the next steps!")
-                
+
+    def reheat_app(self, src_dir, dst_dir, templating_vars, reheat_level=1):
+        essentials = ['app.py', 'metadata.py', 'cli.py', 'Containerfile', 'requirements.txt']
+        for template in src_dir.glob("**/*.template"):
+            dirname = template.relative_to(src_dir).parent
+            basename = template.with_suffix('').name
+            if basename not in essentials:
+                # if non-essential, just skip when updating
+                continue
+            in_f = open(template, 'r')
+            tmpl_to_compile = Template(in_f.read())
+            compiled = tmpl_to_compile.safe_substitute(templating_vars)
+            in_f.close()
+            ori_fpath = dst_dir / dirname / basename
+            if not ori_fpath.exists():
+                # this file is new in this version of cookiecutter 
+                with open(ori_fpath, 'w') as out_f:
+                    out_f.write(compiled)
+            else:
+                ori_f = open(ori_fpath, 'r')
+                ori_content = ori_f.read()
+                if ori_content != compiled:
+                    # when the target file already exists, we need to do diff & patch 
+                    # TODO (krim @ 5/5/24): add update level 2 and 3 code here
+                    out_fpath = f'{ori_fpath}{update_tmp_suffix}'
+                    print(f'    {dst_dir / dirname / basename} already exists, generating a tmp file: {out_fpath}')
+                    with open(out_fpath, 'w') as out_f:
+                        out_f.write(compiled)
+                else:
+                    print(f'    {dst_dir / dirname / basename} already exists, but the content is unchanged from the '
+                          f'template, skipping re-generating')
+        print(f"App skeleton code is updated in {self.rawname}")
+        print(f"  Checkout {self.rawname}/README.md for the next steps!")
+
     def bake_gha(self, src_dir, dst_dir):
         self.simple_recursive_copy_minus_template_suffix(src_dir, dst_dir)
         print(f"GitHub Actions workflow files are copied to {self.rawname}/.github")
@@ -128,12 +168,22 @@ def prep_argparser(**kwargs):
         nargs='?',
         help='The name of the parent directory where the app skeleton directory is placed. (default: current directory)'
     )
+    parser.add_argument(
+        '-u', '--update',
+        action='count',
+        help=f'Set update level by passing this flag multiple times. This is EXPERIMENTAL, and developers MUST NOT'
+             f'rely on the update results, and should conduct manual checks afterward. LEVEL 0: does not update and '
+             f'raise an error when existing directory found. LEVEL 1: generate non-existing files and generate '
+             f'`{update_tmp_suffix}`-suffixed files for existing one. LEVEL 2 (WIP): generate non-existing files and '
+             f'automatically generate patch files for existing files. LEVEL 3 (WIP): generate non-existing files and '
+             f'apply patches to existing files. (default: 0)'
+    )
     return parser
 
 
 def main(args):
     cutter = CookieCutter(name=args.name, outdir=args.parent_dir, recipes=args.recipes)
-    cutter.bake()
+    cutter.bake(args.update)
 
 if __name__ == '__main__':
     parser = prep_argparser()

{clams_python-1.2.1 → clams_python-1.2.3}/clams/develop/templates/app/Containerfile.template

@@ -14,6 +14,20 @@ ARG CLAMS_APP_VERSION
 ENV CLAMS_APP_VERSION ${CLAMS_APP_VERSION}
 ################################################################################
 
+################################################################################
+# This is duplicate from the base image Containerfile 
+# but makes sure the cache directories are consistent across all CLAMS apps
+
+# https://github.com/openai/whisper/blob/ba3f3cd54b0e5b8ce1ab3de13e32122d0d5f98ab/whisper/__init__.py#L130
+ENV XDG_CACHE_HOME='/cache'  
+# https://huggingface.co/docs/huggingface_hub/main/en/package_reference/environment_variables#hfhome
+ENV HF_HOME="/cache/huggingface"
+# https://pytorch.org/docs/stable/hub.html#where-are-my-downloaded-models-saved
+ENV TORCH_HOME="/cache/torch"
+
+RUN mkdir /cache && rm -rf /root/.cache && ln -s /cache /root/.cache
+################################################################################
+
 ################################################################################
 # clams-python base images are based on debian distro
 # install more system packages as needed using the apt manager

{clams_python-1.2.1 → clams_python-1.2.3}/clams/develop/templates/app/app.py.template

@@ -39,6 +39,16 @@ class $APP_CLASS_NAME(ClamsApp):
         # see https://sdk.clams.ai/autodoc/clams.app.html#clams.app.ClamsApp._annotate
         raise NotImplementedError
 
+def get_app():
+    """
+    This function effectively creates an instance of the app class, without any arguments passed in, meaning, any 
+    external information such as initial app configuration should be set without using function arguments. The easiest
+    way to do this is to set global variables before calling this. 
+    """
+    # for example: 
+    # return $APP_CLASS_NAME(create, from, global, params)
+    raise NotImplementedError
+    
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
@@ -50,7 +60,9 @@ if __name__ == "__main__":
     parsed_args = parser.parse_args()
 
     # create the app instance
-    app = $APP_CLASS_NAME()
+    # if get_app() call requires any "configurations", they should be set now as global variables
+    # and referenced in the get_app() function. NOTE THAT you should not change the signature of get_app()
+    app = get_app()
 
     http_app = Restifier(app, port=int(parsed_args.port))
     # for running the application in production mode

clams_python-1.2.3/clams/develop/templates/app/cli.py.template

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+The purpose of this file is to define a thin CLI interface for your app
+
+DO NOT CHANGE the name of the file
+"""
+
+import argparse
+import sys
+from contextlib import redirect_stdout
+
+import app
+
+import clams.app
+from clams import AppMetadata
+
+
+def metadata_to_argparser(app_metadata: AppMetadata) -> argparse.ArgumentParser:
+    """
+    Automatically generate an argparse.ArgumentParser from parameters specified in the app metadata (metadata.py).
+    """
+
+    parser = argparse.ArgumentParser(
+        description=f"{app_metadata.name}: {app_metadata.description} (visit {app_metadata.url} for more info)",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+
+    # parse cli args from app parameters
+    for parameter in app_metadata.parameters:
+        if parameter.multivalued:
+            a = parser.add_argument(
+                f"--{parameter.name}",
+                help=parameter.description,
+                nargs='+',
+                action='extend',
+                type=str
+            )
+        else:
+            a = parser.add_argument(
+                f"--{parameter.name}",
+                help=parameter.description,
+                nargs=1,
+                action="store",
+                type=str)
+        if parameter.choices is not None:
+            a.choices = parameter.choices
+        if parameter.default is not None:
+            a.help += f" (default: {parameter.default}"
+            if parameter.type == "boolean":
+                a.help += (f", any value except for {[v for v in clams.app.falsy_values if isinstance(v, str)]} "
+                           f"will be interpreted as True")
+            a.help += ')'
+            # then we don't have to add default values to the arg_parser
+            # since that's handled by the app._refined_params() method.
+    parser.add_argument('IN_MMIF_FILE', nargs='?', type=argparse.FileType('r'),
+                        help='input MMIF file path, or STDIN if `-` or not provided. NOTE: When running this cli.py in '
+                             'a containerized environment, make sure the container is run with `-i` flag to keep stdin '
+                             'open.',
+                        # will check if stdin is a keyboard, and return None if it is
+                        default=None if sys.stdin.isatty() else sys.stdin)
+    parser.add_argument('OUT_MMIF_FILE', nargs='?', type=argparse.FileType('w'), 
+                        help='output MMIF file path, or STDOUT if `-` or not provided. NOTE: When this is set to '
+                             'STDOUT, any print statements in the app code will be redirected to stderr.',
+                        default=sys.stdout)
+    return parser
+
+
+if __name__ == "__main__":
+    clamsapp = app.get_app()
+    arg_parser = metadata_to_argparser(app_metadata=clamsapp.metadata)
+    args = arg_parser.parse_args()
+    if args.IN_MMIF_FILE:
+        in_data = args.IN_MMIF_FILE.read()
+        # since flask webapp interface will pass parameters as "unflattened" dict to handle multivalued parameters
+        # (https://werkzeug.palletsprojects.com/en/latest/datastructures/#werkzeug.datastructures.MultiDict.to_dict)
+        # we need to convert arg_parsers results into a similar structure, which is the dict values are wrapped in lists
+        params = {}
+        for pname, pvalue in vars(args).items():
+            if pvalue is None or pname in ['IN_MMIF_FILE', 'OUT_MMIF_FILE']:
+                continue
+            elif isinstance(pvalue, list):
+                params[pname] = pvalue
+            else:
+                params[pname] = [pvalue]
+        if args.OUT_MMIF_FILE.name == '<stdout>':
+            with redirect_stdout(sys.stderr):
+                out_mmif = clamsapp.annotate(in_data, **params)
+        else:
+            out_mmif = clamsapp.annotate(in_data, **params)
+        args.OUT_MMIF_FILE.write(out_mmif)
+    else:
+        arg_parser.print_help()
+        sys.exit(1)

{clams_python-1.2.1 → clams_python-1.2.3}/clams/mmif_utils/rewind.py

@@ -77,10 +77,14 @@ def describe_argparser():
 def prep_argparser(**kwargs):
     parser = argparse.ArgumentParser(description=describe_argparser()[1], 
                                      formatter_class=argparse.RawDescriptionHelpFormatter, **kwargs)
-    parser.add_argument("mmif_file", 
-                        help="Path to the input MMIF file, or '-' to read from stdin.")
-    parser.add_argument("-o", '--output', default=None, metavar="PATH", 
-                        help="Path to the rewound MMIF output file. When not given, the rewound is printed to stdout.")
+    parser.add_argument("IN_MMIF_FILE",
+                        nargs="?", type=argparse.FileType("r"),
+                        default=None if sys.stdin.isatty() else sys.stdin,
+                        help='input MMIF file path, or STDIN if `-` or not provided.')
+    parser.add_argument("OUT_MMIF_FILE",
+                        nargs="?", type=argparse.FileType("w"),
+                        default=sys.stdout,
+                        help='output MMIF file path, or STDOUT if `-` or not provided.')
     parser.add_argument("-p", '--pretty', action='store_true', 
                         help="Pretty-print rewound MMIF")
     parser.add_argument("-n", '--number', default="0", type=int,
@@ -92,7 +96,7 @@ def prep_argparser(**kwargs):
 
 
 def main(args):
-    mmif_obj = mmif.Mmif(str(sys.stdin)) if args.mmif_file[0] == '-' else mmif.Mmif(open(args.mmif_file).read())
+    mmif_obj = mmif.Mmif(args.IN_MMIF_FILE.read())
 
     if args.number == 0:  # If user doesn't know how many views to rewind, give them choices.
         choice = prompt_user(mmif_obj)
@@ -101,22 +105,7 @@ def main(args):
     if not isinstance(choice, int) or choice <= 0:
         raise ValueError(f"Only can rewind by a positive number of views. Got {choice}.")
 
-    if args.output:
-        # Check if the same file name exist in the path and avoid overwriting.
-        output_fp = P(args.output)
-        if output_fp.is_file():
-            parent = output_fp.parent
-            stem = output_fp.stem
-            suffix = output_fp.suffix
-            count = 1
-            while (parent / f"{stem}_{count}{suffix}").is_file():
-                count += 1
-            output_fp = parent / f"{stem}_{count}{suffix}"
-        
-        out_f = open(output_fp, 'w')
-    else:
-        out_f = sys.stdout
-    out_f.write(rewind_mmif(mmif_obj, choice, args.mode == 'view').serialize(pretty=args.pretty))
+    args.OUT_MMIF_FILE.write(rewind_mmif(mmif_obj, choice, args.mode == 'view').serialize(pretty=args.pretty))
 
 
 if __name__ == "__main__":

{clams_python-1.2.1 → clams_python-1.2.3}/clams/restify/__init__.py

@@ -124,7 +124,9 @@ class ClamsHTTPApi(Resource):
 
         :return: Returns app metadata in a HTTP response.
         """
-        return self.json_to_response(self.cla.appmetadata(**request.args))
+        # this will catch duplicate arguments with different values into a list under the key
+        raw_params = request.args.to_dict(flat=False)
+        return self.json_to_response(self.cla.appmetadata(**raw_params))
 
     def post(self) -> Response:
         """
@@ -143,6 +145,7 @@ class ClamsHTTPApi(Resource):
         try:
             return self.json_to_response(self.cla.annotate(raw_data, **raw_params))
         except Exception:
+            self.cla.logger.exception("Error in annotation")
             return self.json_to_response(self.cla.record_error(raw_data, **raw_params).serialize(pretty=True), status=500)
 
     put = post

clams_python-1.2.3/clams/ver/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.2.3"

{clams_python-1.2.1 → clams_python-1.2.3/clams_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clams-python
-Version: 1.2.1
+Version: 1.2.3
 Summary: A collection of APIs to develop CLAMS app for python
 Home-page: https://clams.ai
 Author: Brandeis Lab for Linguistics and Computation
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mmif-python==1.0.13
+Requires-Dist: mmif-python==1.0.15
 Requires-Dist: Flask>=2
 Requires-Dist: Flask-RESTful>=0.3.9
 Requires-Dist: gunicorn>=20

{clams_python-1.2.1 → clams_python-1.2.3}/clams_python.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ clams/develop/templates/app/Containerfile.template
 clams/develop/templates/app/LICENSE.template
 clams/develop/templates/app/README.md.template
 clams/develop/templates/app/app.py.template
+clams/develop/templates/app/cli.py.template
 clams/develop/templates/app/metadata.py.template
 clams/develop/templates/app/requirements.txt.template
 clams/develop/templates/gha/for-clams-team.md.template

{clams_python-1.2.1 → clams_python-1.2.3}/clams_python.egg-info/requires.txt

@@ -1,4 +1,4 @@
-mmif-python==1.0.13
+mmif-python==1.0.15
 Flask>=2
 Flask-RESTful>=0.3.9
 gunicorn>=20

{clams_python-1.2.1 → clams_python-1.2.3}/requirements.txt

@@ -1,4 +1,4 @@
-mmif-python==1.0.13
+mmif-python==1.0.15
 
 Flask>=2
 Flask-RESTful>=0.3.9

{clams_python-1.2.1 → clams_python-1.2.3}/tests/test_clamsapp.py

@@ -236,8 +236,8 @@ class TestClamsApp(unittest.TestCase):
         self.assertEqual(v1.metadata.app, self.app.metadata.identifier)
         self.assertEqual(len(v1.metadata.parameters), 0)
         v2 = m.new_view()
-        raw_query_string_arguments = {'undefined_param1': ['value1']}  # values are lists as our restifier uses `to_dict(flat=False)`
-        self.app.sign_view(v2, self.app._refine_params(**raw_query_string_arguments))
+        args2 = {'undefined_param1': ['value1']}  # values are lists as our restifier uses `to_dict(flat=False)`
+        self.app.sign_view(v2, self.app._refine_params(**args2))
         self.assertEqual(v2.metadata.app, self.app.metadata.identifier)
         self.assertEqual(len(v2.metadata.parameters), 1)
         self.assertFalse(clams.ClamsApp._RAW_PARAMS_KEY in v2.metadata.appConfiguration)
@@ -245,8 +245,22 @@ class TestClamsApp(unittest.TestCase):
             # any parameter with defaults should be recorded
             if param.default is not None:
                 self.assertTrue(param.name in v2.metadata.appConfiguration)
-            elif param.name not in raw_query_string_arguments:
+            elif param.name not in args2:
                 self.assertFalse(param.name in v2.metadata.appConfiguration)
+        v3 = m.new_view()
+        self.app.metadata.add_parameter('multivalued_param', 'dummy parameter with multivalues', type='string', multivalued=True, default=[])
+        args3 = {'undefined_param1': ['value1']} 
+        self.app.sign_view(v3, self.app._refine_params(**args3))
+        self.assertEqual(len(v3.metadata.parameters), 1)
+        self.assertEqual(len(v3.metadata.appConfiguration), 3)  # universal (pretty) + `raise_error` in metadata.py + `multivalued_param`
+        self.assertEqual(v3.metadata.appConfiguration['multivalued_param'], [])
+        v4 = m.new_view()
+        multiple_values = ['value1', 'value2']
+        args4 = {'multivalued_param': multiple_values}
+        self.app.sign_view(v4, self.app._refine_params(**args4))
+        self.assertEqual(len(v4.metadata.parameters), 1)
+        self.assertEqual(len(v4.metadata.appConfiguration), 3)
+        self.assertEqual(len(v4.metadata.parameters['multivalued_param']), len(str(multiple_values)))
 
     def test_annotate(self):
         # The example app is hard-coded to **always** emit version mismatch warning
@@ -307,6 +321,10 @@ class TestClamsApp(unittest.TestCase):
                                         description='float +def +mv')
         self.app.metadata.add_parameter('param7', type='number', default=[], multivalued=True,
                                         description='float +def +empty +mv')
+        # need to manually rebuild caster object, because the metadata has updated after the app is initialized
+        for param_spec in self.app.metadata.parameters:
+            self.app.annotate_param_spec[param_spec.name] = (param_spec.type, param_spec.multivalued)
+        self.app.annotate_param_caster = ParameterCaster(self.app.annotate_param_spec)
         with self.assertRaises(ValueError):
             self.app._refine_params(**{})  # param1 is required, but not passed
         dummy_params = {'param1': ['okay'], 'non_parameter': ['should be ignored']}
@@ -375,7 +393,7 @@ class TestRestifier(unittest.TestCase):
     def test_can_put_as_json(self):
         put = self.app.put('/', data=ExampleInputMMIF.get_mmif(), headers={"Content-Type": "Application/json"})
         self.assertIsNotNone(put)
-        self.assertEqual(put.status_code, 200)
+        self.assertEqual(200, put.status_code)
         self.assertIsNotNone(Mmif(put.get_data(as_text=True)))
 
     def test_can_pass_params(self):

clams_python-1.2.1/VERSION

@@ -1 +0,0 @@
-1.2.1

clams_python-1.2.1/clams/ver/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.2.1"