dcicutils 8.5.0.1b4__py3-none-any.whl → 8.5.0.1b7__py3-none-any.whl

dcicutils/portal_utils.py

@@ -1,19 +1,24 @@
 from collections import deque
-from pyramid.paster import get_app
-from pyramid.router import Router
+import io
+import json
+from pyramid.config import Configurator as PyramidConfigurator
+from pyramid.paster import get_app as pyramid_get_app
+from pyramid.response import Response as PyramidResponse
+from pyramid.router import Router as PyramidRouter
+import os
 import re
 import requests
 from requests.models import Response as RequestResponse
-from typing import Optional, Type, Union
+from typing import Callable, Dict, List, Optional, Type, Union
+from uuid import uuid4 as uuid
+# from waitress import serve
 from webtest.app import TestApp, TestResponse
-from dcicutils.common import OrchestratedApp, APP_CGAP, APP_FOURFRONT, APP_SMAHT, ORCHESTRATED_APPS
-from dcicutils.creds_utils import CGAPKeyManager, FourfrontKeyManager, SMaHTKeyManager
+from dcicutils.common import OrchestratedApp, ORCHESTRATED_APPS
 from dcicutils.ff_utils import get_metadata, get_schema, patch_metadata, post_metadata
 from dcicutils.misc_utils import to_camel_case, VirtualApp
 from dcicutils.zip_utils import temporary_file
 
 Portal = Type["Portal"]  # Forward type reference for type hints.
-FILE_SCHEMA_NAME = "File"
 
 
 class Portal:
@@ -32,105 +37,166 @@ class Portal:
     6. From a given "vapp" value (which is assumed to be a TestApp or VirtualApp).
     7. From another Portal object; or from a a pyramid Router object.
     """
+    FILE_SCHEMA_NAME = "File"
+    KEYS_FILE_DIRECTORY = os.path.expanduser(f"~")
+
     def __init__(self,
-                 arg: Optional[Union[VirtualApp, TestApp, Router, Portal, dict, tuple, str]] = None,
-                 env: Optional[str] = None, app: Optional[OrchestratedApp] = None, server: Optional[str] = None,
-                 key: Optional[Union[dict, tuple]] = None,
-                 vapp: Optional[Union[VirtualApp, TestApp, Router, Portal, str]] = None,
-                 portal: Optional[Union[VirtualApp, TestApp, Router, Portal, str]] = None) -> Portal:
-        if vapp and not portal:
-            portal = vapp
-        if ((isinstance(arg, (VirtualApp, TestApp, Router, Portal)) or
-             isinstance(arg, str) and arg.endswith(".ini")) and not portal):
-            portal = arg
-        elif isinstance(arg, str) and not env:
-            env = arg
-        elif (isinstance(arg, dict) or isinstance(arg, tuple)) and not key:
-            key = arg
-        if not app and env:
-            if env.startswith(APP_SMAHT):
-                app = APP_SMAHT
-            elif env.startswith(APP_CGAP):
-                app = APP_CGAP
-            elif env.startswith(APP_FOURFRONT):
-                app = APP_FOURFRONT
-        if isinstance(portal, Portal):
-            self._vapp = portal._vapp
-            self._env = portal._env
-            self._app = portal._app
-            self._server = portal._server
+                 arg: Optional[Union[Portal, TestApp, VirtualApp, PyramidRouter, dict, tuple, str]] = None,
+                 env: Optional[str] = None, server: Optional[str] = None,
+                 app: Optional[OrchestratedApp] = None) -> None:
+
+        def init(unspecified: Optional[list] = []) -> None:
+            self._ini_file = None
+            self._key = None
+            self._key_pair = None
+            self._key_id = None
+            self._secret = None
+            self._keys_file = None
+            self._env = None
+            self._server = None
+            self._app = None
+            self._vapp = None
+            for arg in unspecified:
+                if arg is not None:
+                    raise Exception("Portal init error; extraneous args.")
+
+        def init_from_portal(portal: Portal, unspecified: Optional[list] = None) -> None:
+            init(unspecified)
+            self._ini_file = portal._ini_file
             self._key = portal._key
             self._key_pair = portal._key_pair
             self._key_id = portal._key_id
-            self._key_file = portal._key_file
-            return
-        self._vapp = None
-        self._env = env
-        self._app = app
-        self._server = server
-        self._key = None
-        self._key_pair = None
-        self._key_id = None
-        self._key_file = None
-        if isinstance(portal, (VirtualApp, TestApp)):
-            self._vapp = portal
-        elif isinstance(portal, (Router, str)):
-            self._vapp = Portal._create_vapp(portal)
-        elif isinstance(key, dict):
-            self._key = key
-            self._key_pair = (key.get("key"), key.get("secret")) if key else None
-            if key_server := key.get("server"):
-                self._server = key_server
-        elif isinstance(key, tuple) and len(key) >= 2:
-            self._key = {"key": key[0], "secret": key[1]}
-            self._key_pair = key
-        elif isinstance(env, str):
-            key_managers = {APP_CGAP: CGAPKeyManager, APP_FOURFRONT: FourfrontKeyManager, APP_SMAHT: SMaHTKeyManager}
-            if not (key_manager := key_managers.get(self._app)) or not (key_manager := key_manager()):
-                raise Exception(f"Invalid app name: {self._app} (valid: {', '.join(ORCHESTRATED_APPS)}).")
-            if isinstance(env, str):
-                self._key = key_manager.get_keydict_for_env(env)
-                if key_server := self._key.get("server"):
-                    self._server = key_server
-            elif isinstance(self._server, str):
-                self._key = key_manager.get_keydict_for_server(self._server)
-            self._key_pair = key_manager.keydict_to_keypair(self._key) if self._key else None
-            self._key_file = key_manager.keys_file
-        if self._key and (key_id := self._key.get("key")):
-            self._key_id = key_id
-        elif self._key_pair and (key_id := self._key_pair[1]):
-            self._key_id = key_id
+            self._secret = portal._secret
+            self._keys_file = portal._keys_file
+            self._env = portal._env
+            self._server = portal._server
+            self._app = portal._app
+            self._vapp = portal._vapp
 
-    @property
-    def env(self):
-        return self._env
+        def init_from_vapp(vapp: Union[TestApp, VirtualApp, PyramidRouter], unspecified: Optional[list] = []) -> None:
+            init(unspecified)
+            self._vapp = Portal._create_vapp(vapp)
 
-    @property
-    def app(self):
-        return self._app
+        def init_from_ini_file(ini_file: str, unspecified: Optional[list] = []) -> None:
+            init(unspecified)
+            self._ini_file = ini_file
+            self._vapp = Portal._create_vapp(ini_file)
+
+        def init_from_key(key: dict, server: Optional[str], unspecified: Optional[list] = []) -> None:
+            init(unspecified)
+            if (isinstance(key_id := key.get("key"), str) and key_id and
+                isinstance(secret := key.get("secret"), str) and secret):  # noqa
+                self._key = {"key": key_id, "secret": secret}
+                self._key_id = key_id
+                self._secret = secret
+                self._key_pair = (key_id, secret)
+                if ((isinstance(server, str) and server) or (isinstance(server := key.get("server"), str) and server)):
+                    if server := normalize_server(server):
+                        self._key["server"] = self._server = server
+            if not self._key:
+                raise Exception("Portal init error; from key.")
+
+        def init_from_key_pair(key_pair: tuple, server: Optional[str], unspecified: Optional[list] = []) -> None:
+            if len(key_pair) == 2:
+                init_from_key({"key": key_pair[0], "secret": key_pair[1]}, server, unspecified)
+            else:
+                raise Exception("Portal init error; from key-pair.")
+
+        def init_from_keys_file(keys_file: str, env: Optional[str], server: Optional[str],
+                                unspecified: Optional[list] = []) -> None:
+            try:
+                with io.open(keys_file) as f:
+                    keys = json.load(f)
+            except Exception:
+                raise Exception(f"Portal init error; cannot open keys-file: {keys_file}")
+            if isinstance(env, str) and env and isinstance(key := keys.get(env), dict):
+                init_from_key(key, server)
+                self._keys_file = keys_file
+                self._env = env
+            elif isinstance(server, str) and server and (key := [k for k in keys if keys[k].get("server") == server]):
+                init_from_key(key, server)
+                self._keys_file = keys_file
+            elif len(keys) == 1 and (env := next(iter(keys))) and isinstance(key := keys[env], dict) and key:
+                init_from_key(key, server)
+                self._keys_file = keys_file
+                self._env = env
+            else:
+                raise Exception(f"Portal init error; {env or server or None} not found in keys-file: {keys_file}")
+
+        def init_from_env_server_app(env: str, server: str, app: Optional[str],
+                                     unspecified: Optional[list] = None) -> None:
+            return init_from_keys_file(self._default_keys_file(app, env), env, server, unspecified)
+
+        def normalize_server(server: str) -> Optional[str]:
+            prefix = ""
+            if (lserver := server.lower()).startswith("http://"):
+                prefix = "http://"
+            elif lserver.startswith("https://"):
+                prefix = "https://"
+            if prefix:
+                if (server := re.sub(r"/+", "/", server[len(prefix):])).startswith("/"):
+                    server = server[1:]
+                if len(server) > 1 and server.endswith("/"):
+                    server = server[:-1]
+                return prefix + server if server else None
+
+        if isinstance(arg, Portal):
+            init_from_portal(arg, unspecified=[env, server, app])
+        elif isinstance(arg, (TestApp, VirtualApp, PyramidRouter)):
+            init_from_vapp(arg, unspecified=[env, server, app])
+        elif isinstance(arg, str) and arg.endswith(".ini"):
+            init_from_ini_file(arg, unspecified=[env, server, app])
+        elif isinstance(arg, dict):
+            init_from_key(arg, server, unspecified=[env, app])
+        elif isinstance(arg, tuple):
+            init_from_key_pair(arg, server, unspecified=[env, app])
+        elif isinstance(arg, str) and arg.endswith(".json"):
+            init_from_keys_file(arg, env, server, unspecified=[app])
+        elif isinstance(arg, str) and arg:
+            init_from_env_server_app(arg, server, app, unspecified=[env])
+        elif isinstance(env, str) and env:
+            init_from_env_server_app(env, server, app, unspecified=[arg])
+        else:
+            raise Exception("Portal init error; invalid args.")
 
     @property
-    def server(self):
-        return self._server
+    def ini_file(self) -> Optional[str]:
+        return self._ini_file
 
     @property
-    def key(self):
+    def key(self) -> Optional[dict]:
         return self._key
 
     @property
-    def key_pair(self):
+    def key_pair(self) -> Optional[tuple]:
         return self._key_pair
 
     @property
-    def key_id(self):
+    def key_id(self) -> Optional[str]:
         return self._key_id
 
     @property
-    def key_file(self):
-        return self._key_file
+    def secret(self) -> Optional[str]:
+        return self._secret
+
+    @property
+    def keys_file(self) -> Optional[str]:
+        return self._keys_file
 
     @property
-    def vapp(self):
+    def env(self) -> Optional[str]:
+        return self._env
+
+    @property
+    def server(self) -> Optional[str]:
+        return self._server
+
+    @property
+    def app(self) -> Optional[str]:
+        return self._app
+
+    @property
+    def vapp(self) -> Optional[TestApp]:
         return self._vapp
 
     def get_metadata(self, object_id: str) -> Optional[dict]:
@@ -139,35 +205,36 @@ class Portal:
     def patch_metadata(self, object_id: str, data: str) -> Optional[dict]:
         if self._key:
             return patch_metadata(obj_id=object_id, patch_item=data, key=self._key)
-        return self.patch(f"/{object_id}", data)
+        return self.patch(f"/{object_id}", data).json()
 
     def post_metadata(self, object_type: str, data: str) -> Optional[dict]:
         if self._key:
             return post_metadata(schema_name=object_type, post_item=data, key=self._key)
-        return self.post(f"/{object_type}", data)
+        return self.post(f"/{object_type}", data).json()
 
     def get(self, uri: str, follow: bool = True, **kwargs) -> Optional[Union[RequestResponse, TestResponse]]:
-        if isinstance(self._vapp, (VirtualApp, TestApp)):
-            response = self._vapp.get(self._uri(uri), **self._kwargs(**kwargs))
-            if response and response.status_code in [301, 302, 303, 307, 308] and follow:
-                response = response.follow()
-            return self._response(response)
-        return requests.get(self._uri(uri), allow_redirects=follow, **self._kwargs(**kwargs))
+        if not self._vapp:
+            return requests.get(self.url(uri), allow_redirects=follow, **self._kwargs(**kwargs))
+        response = self._vapp.get(self.url(uri), **self._kwargs(**kwargs))
+        if response and response.status_code in [301, 302, 303, 307, 308] and follow:
+            response = response.follow()
+        return self._response(response)
 
     def patch(self, uri: str, data: Optional[dict] = None,
               json: Optional[dict] = None, **kwargs) -> Optional[Union[RequestResponse, TestResponse]]:
-        if isinstance(self._vapp, (VirtualApp, TestApp)):
-            return self._vapp.patch_json(self._uri(uri), json or data, **self._kwargs(**kwargs))
-        return requests.patch(self._uri(uri), json=json or data, **self._kwargs(**kwargs))
+        if not self._vapp:
+            return requests.patch(self.url(uri), data=data, json=json, **self._kwargs(**kwargs))
+        return self._response(self._vapp.patch_json(self.url(uri), json or data, **self._kwargs(**kwargs)))
 
     def post(self, uri: str, data: Optional[dict] = None, json: Optional[dict] = None,
              files: Optional[dict] = None, **kwargs) -> Optional[Union[RequestResponse, TestResponse]]:
-        if isinstance(self._vapp, (VirtualApp, TestApp)):
-            if files:
-                return self._vapp.post(self._uri(uri), json or data, upload_files=files, **self._kwargs(**kwargs))
-            else:
-                return self._vapp.post_json(self._uri(uri), json or data, upload_files=files, **self._kwargs(**kwargs))
-        return requests.post(self._uri(uri), json=json or data, files=files, **self._kwargs(**kwargs))
+        if not self._vapp:
+            return requests.post(self.url(uri), data=data, json=json, files=files, **self._kwargs(**kwargs))
+        if files:
+            response = self._vapp.post(self.url(uri), json or data, upload_files=files, **self._kwargs(**kwargs))
+        else:
+            response = self._vapp.post_json(self.url(uri), json or data, upload_files=files, **self._kwargs(**kwargs))
+        return self._response(response)
 
     def get_schema(self, schema_name: str) -> Optional[dict]:
         return get_schema(self.schema_name(schema_name), portal_vapp=self._vapp, key=self._key)
@@ -181,7 +248,7 @@ class Portal:
 
     def is_file_schema(self, schema_name: str) -> bool:
         if super_type_map := self.get_schemas_super_type_map():
-            if file_super_type := super_type_map.get(FILE_SCHEMA_NAME):
+            if file_super_type := super_type_map.get(Portal.FILE_SCHEMA_NAME):
                 return self.schema_name(schema_name) in file_super_type
         return False
 
@@ -221,13 +288,14 @@ class Portal:
         except Exception:
             return False
 
-    def _uri(self, uri: str) -> str:
+    def url(self, uri: str) -> str:
         if not isinstance(uri, str) or not uri:
             return "/"
-        if uri.lower().startswith("http://") or uri.lower().startswith("https://"):
+        if (luri := uri.lower()).startswith("http://") or luri.startswith("https://"):
             return uri
-        uri = re.sub(r"/+", "/", uri)
-        return (self._server + ("/" if not uri.startswith("/") else "") + uri) if self._server else uri
+        if not (uri := re.sub(r"/+", "/", uri)).startswith("/"):
+            uri = "/"
+        return self._server + uri if self._server else uri
 
     def _kwargs(self, **kwargs) -> dict:
         result_kwargs = {"headers":
@@ -238,7 +306,17 @@ class Portal:
             result_kwargs["timeout"] = timeout
         return result_kwargs
 
-    def _response(self, response) -> Optional[RequestResponse]:
+    def _default_keys_file(self, app: Optional[str], env: Optional[str] = None) -> Optional[str]:
+        def is_valid_app(app: Optional[str]) -> bool:  # noqa
+            return app and app.lower() in [name.lower() for name in ORCHESTRATED_APPS]
+        def infer_app_from_env(env: str) -> Optional[str]:  # noqa
+            if isinstance(env, str) and (lenv := env.lower()):
+                if app := [app for app in ORCHESTRATED_APPS if lenv.startswith(app.lower())]:
+                    return app[0]
+        if is_valid_app(app) or (app := infer_app_from_env(env)):
+            return os.path.join(Portal.KEYS_FILE_DIRECTORY, f".{app.lower()}-keys.json")
+
+    def _response(self, response: TestResponse) -> Optional[RequestResponse]:
         if response and isinstance(getattr(response.__class__, "json"), property):
             class RequestResponseWrapper:  # For consistency change json property to method.
                 def __init__(self, response, **kwargs):
@@ -252,42 +330,72 @@ class Portal:
         return response
 
     @staticmethod
-    def create_for_testing(ini_file: Optional[str] = None) -> Portal:
-        if isinstance(ini_file, str):
-            return Portal(Portal._create_vapp(ini_file))
-        minimal_ini_for_unit_testing = "[app:app]\nuse = egg:encoded\nsqlalchemy.url = postgresql://dummy\n"
-        with temporary_file(content=minimal_ini_for_unit_testing, suffix=".ini") as ini_file:
+    def create_for_testing(arg: Optional[Union[str, bool, List[dict], dict, Callable]] = None) -> Portal:
+        if isinstance(arg, list) or isinstance(arg, dict) or isinstance(arg, Callable):
+            return Portal(Portal._create_router_for_testing(arg))
+        if isinstance(arg, str) and arg.endswith(".ini"):
+            return Portal(Portal._create_vapp(arg))
+        if arg == "local" or arg is True:
+            minimal_ini_for_testing = "\n".join([
+                "[app:app]\nuse = egg:encoded\nfile_upload_bucket = dummy",
+                "sqlalchemy.url = postgresql://postgres@localhost:5441/postgres?host=/tmp/snovault/pgdata",
+                "multiauth.groupfinder = encoded.authorization.smaht_groupfinder",
+                "multiauth.policies = auth0 session remoteuser accesskey",
+                "multiauth.policy.session.namespace = mailto",
+                "multiauth.policy.session.use = encoded.authentication.NamespacedAuthenticationPolicy",
+                "multiauth.policy.session.base = pyramid.authentication.SessionAuthenticationPolicy",
+                "multiauth.policy.remoteuser.namespace = remoteuser",
+                "multiauth.policy.remoteuser.use = encoded.authentication.NamespacedAuthenticationPolicy",
+                "multiauth.policy.remoteuser.base = pyramid.authentication.RemoteUserAuthenticationPolicy",
+                "multiauth.policy.accesskey.namespace = accesskey",
+                "multiauth.policy.accesskey.use = encoded.authentication.NamespacedAuthenticationPolicy",
+                "multiauth.policy.accesskey.base = encoded.authentication.BasicAuthAuthenticationPolicy",
+                "multiauth.policy.accesskey.check = encoded.authentication.basic_auth_check",
+                "multiauth.policy.auth0.use = encoded.authentication.NamespacedAuthenticationPolicy",
+                "multiauth.policy.auth0.namespace = auth0",
+                "multiauth.policy.auth0.base = encoded.authentication.Auth0AuthenticationPolicy"
+            ])
+        else:
+            minimal_ini_for_testing = "[app:app]\nuse = egg:encoded\nsqlalchemy.url = postgresql://dummy\n"
+        with temporary_file(content=minimal_ini_for_testing, suffix=".ini") as ini_file:
             return Portal(Portal._create_vapp(ini_file))
 
     @staticmethod
-    def create_for_testing_local(ini_file: Optional[str] = None) -> Portal:
-        if isinstance(ini_file, str) and ini_file:
-            return Portal(Portal._create_vapp(ini_file))
-        minimal_ini_for_testing_local = "\n".join([
-            "[app:app]\nuse = egg:encoded\nfile_upload_bucket = dummy",
-            "sqlalchemy.url = postgresql://postgres@localhost:5441/postgres?host=/tmp/snovault/pgdata",
-            "multiauth.groupfinder = encoded.authorization.smaht_groupfinder",
-            "multiauth.policies = auth0 session remoteuser accesskey",
-            "multiauth.policy.session.namespace = mailto",
-            "multiauth.policy.session.use = encoded.authentication.NamespacedAuthenticationPolicy",
-            "multiauth.policy.session.base = pyramid.authentication.SessionAuthenticationPolicy",
-            "multiauth.policy.remoteuser.namespace = remoteuser",
-            "multiauth.policy.remoteuser.use = encoded.authentication.NamespacedAuthenticationPolicy",
-            "multiauth.policy.remoteuser.base = pyramid.authentication.RemoteUserAuthenticationPolicy",
-            "multiauth.policy.accesskey.namespace = accesskey",
-            "multiauth.policy.accesskey.use = encoded.authentication.NamespacedAuthenticationPolicy",
-            "multiauth.policy.accesskey.base = encoded.authentication.BasicAuthAuthenticationPolicy",
-            "multiauth.policy.accesskey.check = encoded.authentication.basic_auth_check",
-            "multiauth.policy.auth0.use = encoded.authentication.NamespacedAuthenticationPolicy",
-            "multiauth.policy.auth0.namespace = auth0",
-            "multiauth.policy.auth0.base = encoded.authentication.Auth0AuthenticationPolicy"
-        ])
-        with temporary_file(content=minimal_ini_for_testing_local, suffix=".ini") as minimal_ini_file:
-            return Portal(Portal._create_vapp(minimal_ini_file))
+    def _create_vapp(arg: Union[TestApp, VirtualApp, PyramidRouter, str] = None) -> TestApp:
+        if isinstance(arg, TestApp):
+            return arg
+        elif isinstance(arg, VirtualApp):
+            if not isinstance(arg.wrapped_app, TestApp):
+                raise Exception("Portal._create_vapp VirtualApp argument error.")
+            return arg.wrapped_app
+        if isinstance(arg, PyramidRouter):
+            router = arg
+        elif isinstance(arg, str) or not arg:
+            router = pyramid_get_app(arg or "development.ini", "app")
+        else:
+            raise Exception("Portal._create_vapp argument error.")
+        return TestApp(router, {"HTTP_ACCEPT": "application/json", "REMOTE_USER": "TEST"})
 
     @staticmethod
-    def _create_vapp(value: Union[str, Router, TestApp] = "development.ini", app_name: str = "app") -> TestApp:
-        if isinstance(value, TestApp):
-            return value
-        app = value if isinstance(value, Router) else get_app(value, app_name)
-        return TestApp(app, {"HTTP_ACCEPT": "application/json", "REMOTE_USER": "TEST"})
+    def _create_router_for_testing(endpoints: Optional[List[Dict[str, Union[str, Callable]]]] = None):
+        if isinstance(endpoints, dict):
+            endpoints = [endpoints]
+        elif isinstance(endpoints, Callable):
+            endpoints = [{"path": "/", "method": "GET", "function": endpoints}]
+        if not isinstance(endpoints, list) or not endpoints:
+            endpoints = [{"path": "/", "method": "GET", "function": lambda request: {"status": "OK"}}]
+        with PyramidConfigurator() as config:
+            nendpoints = 0
+            for endpoint in endpoints:
+                if (endpoint_path := endpoint.get("path")) and (endpoint_function := endpoint.get("function")):
+                    endpoint_method = endpoint.get("method", "GET")
+                    def endpoint_wrapper(request):  # noqa
+                        response = endpoint_function(request)
+                        return PyramidResponse(json.dumps(response), content_type="application/json; charset=utf-8")
+                    endpoint_id = str(uuid())
+                    config.add_route(endpoint_id, endpoint_path)
+                    config.add_view(endpoint_wrapper, route_name=endpoint_id, request_method=endpoint_method)
+                    nendpoints += 1
+            if nendpoints == 0:
+                return Portal._create_router_for_testing([])
+            return config.make_wsgi_app()

dcicutils/structured_data.py

@@ -43,8 +43,8 @@ class StructuredDataSet:
 
     def __init__(self, file: Optional[str] = None, portal: Optional[Union[VirtualApp, TestApp, Portal]] = None,
                  schemas: Optional[List[dict]] = None, autoadd: Optional[dict] = None,
-                 data: Optional[List[dict]] = None, order: Optional[List[str]] = None, prune: bool = True) -> None:
-        self.data = {} if not data else data  # If portal is None then no schemas nor refs.
+                 order: Optional[List[str]] = None, prune: bool = True) -> None:
+        self.data = {}
         self._portal = Portal(portal, data=self.data, schemas=schemas) if portal else None
         self._order = order
         self._prune = prune
@@ -113,7 +113,7 @@ class StructuredDataSet:
     def _load_file(self, file: str) -> None:
         # Returns a dictionary where each property is the name (i.e. the type) of the data,
         # and the value is array of dictionaries for the data itself. Handle these kinds of files:
-        # 1.  Single CSV of JSON file, where the (base) name of the file is the data type name.
+        # 1.  Single CSV, TSV, or JSON file, where the (base) name of the file is the data type name.
         # 2.  Single Excel file containing one or more sheets, where each sheet
         #     represents (i.e. is named for, and contains data for) a different type.
         # 3.  Zip file (.zip or .tar.gz or .tgz or .tar), containing data files to load, where the
@@ -483,7 +483,6 @@ class Schema:
                 if unique:
                     typeinfo[key]["unique"] = True
                 result.update(typeinfo)
-#               result.update(self._create_typeinfo(array_property_items, parent_key=key))
                 continue
             result[key] = {"type": property_value_type, "map": self._map_function({**property_value, "column": key})}
             if ARRAY_NAME_SUFFIX_CHAR in key:
@@ -551,16 +550,13 @@ class Portal(PortalBase):
 
     def __init__(self,
                  arg: Optional[Union[VirtualApp, TestApp, Router, Portal, dict, tuple, str]] = None,
-                 env: Optional[str] = None, app: OrchestratedApp = None, server: Optional[str] = None,
-                 key: Optional[Union[dict, tuple]] = None,
-                 portal: Optional[Union[VirtualApp, TestApp, Router, Portal, str]] = None,
-                 data: Optional[dict] = None, schemas: Optional[List[dict]] = None) -> Optional[Portal]:
-        super().__init__(arg, env=env, app=app, server=server, key=key, portal=portal)
-        if isinstance(arg, Portal) and not portal:
-            portal = arg
-        if isinstance(portal, Portal):
-            self._schemas = schemas if schemas is not None else portal._schemas  # Explicitly specified/known schemas.
-            self._data = data if data is not None else portal._data  # Data set being loaded; e.g. by StructuredDataSet.
+                 env: Optional[str] = None, server: Optional[str] = None,
+                 app: Optional[OrchestratedApp] = None,
+                 data: Optional[dict] = None, schemas: Optional[List[dict]] = None) -> None:
+        super().__init__(arg, env=env, server=server, app=app)
+        if isinstance(arg, Portal):
+            self._schemas = schemas if schemas is not None else arg._schemas  # Explicitly specified/known schemas.
+            self._data = data if data is not None else arg._data  # Data set being loaded; e.g. by StructuredDataSet.
         else:
             self._schemas = schemas
             self._data = data
@@ -620,12 +616,9 @@ class Portal(PortalBase):
         return self.get_metadata(f"/{type_name}/{value}") is not None
 
     @staticmethod
-    def create_for_testing(ini_file: Optional[str] = None, schemas: Optional[List[dict]] = None) -> Portal:
-        return Portal(PortalBase.create_for_testing(ini_file), schemas=schemas)
-
-    @staticmethod
-    def create_for_testing_local(ini_file: Optional[str] = None, schemas: Optional[List[dict]] = None) -> Portal:
-        return Portal(PortalBase.create_for_testing_local(ini_file), schemas=schemas)
+    def create_for_testing(arg: Optional[Union[str, bool, List[dict], dict, Callable]] = None,
+                           schemas: Optional[List[dict]] = None) -> Portal:
+        return Portal(PortalBase.create_for_testing(arg), schemas=schemas)
 
 
 def _split_dotted_string(value: str):

{dcicutils-8.5.0.1b4.dist-info → dcicutils-8.5.0.1b7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.5.0.1b4
+Version: 8.5.0.1b7
 Summary: Utility package for interacting with the 4DN Data Portal and other 4DN resources
 Home-page: https://github.com/4dn-dcic/utils
 License: MIT

{dcicutils-8.5.0.1b4.dist-info → dcicutils-8.5.0.1b7.dist-info}/RECORD

@@ -43,7 +43,7 @@ dcicutils/log_utils.py,sha256=7pWMc6vyrorUZQf-V-M3YC6zrPgNhuV_fzm9xqTPph0,10883
 dcicutils/misc_utils.py,sha256=nRjLEORY35YmJwTjO0fnauBPznaI_bkVasIW8PccDYM,100179
 dcicutils/obfuscation_utils.py,sha256=fo2jOmDRC6xWpYX49u80bVNisqRRoPskFNX3ymFAmjw,5963
 dcicutils/opensearch_utils.py,sha256=V2exmFYW8Xl2_pGFixF4I2Cc549Opwe4PhFi5twC0M8,1017
-dcicutils/portal_utils.py,sha256=Wh918ZKpUJFbt7w6Bn5G7v-0k6ImOUWMFmE9Oxt1ZN4,14560
+dcicutils/portal_utils.py,sha256=IZfwtbkirNiSSvpUzkQxHBedzaSgMiiVbkLLKzHEvVI,20043
 dcicutils/project_utils.py,sha256=qPdCaFmWUVBJw4rw342iUytwdQC0P-XKpK4mhyIulMM,31250
 dcicutils/qa_checkers.py,sha256=cdXjeL0jCDFDLT8VR8Px78aS10hwNISOO5G_Zv2TZ6M,20534
 dcicutils/qa_utils.py,sha256=TT0SiJWiuxYvbsIyhK9VO4uV_suxhB6CpuC4qPacCzQ,160208
@@ -56,14 +56,14 @@ dcicutils/secrets_utils.py,sha256=8dppXAsiHhJzI6NmOcvJV5ldvKkQZzh3Fl-cb8Wm7MI,19
 dcicutils/sheet_utils.py,sha256=VlmzteONW5VF_Q4vo0yA5vesz1ViUah1MZ_yA1rwZ0M,33629
 dcicutils/snapshot_utils.py,sha256=ymP7PXH6-yEiXAt75w0ldQFciGNqWBClNxC5gfX2FnY,22961
 dcicutils/ssl_certificate_utils.py,sha256=F0ifz_wnRRN9dfrfsz7aCp4UDLgHEY8LaK7PjnNvrAQ,9707
-dcicutils/structured_data.py,sha256=tMKBhq6OuM2t6iDxIPBFcxV66MiwmOHTBeACxhvkbiQ,33307
+dcicutils/structured_data.py,sha256=ziugsIE_FlYRFQIl2GJqwduRa4yIBPbHBQRYPSeUzSk,32713
 dcicutils/task_utils.py,sha256=MF8ujmTD6-O2AC2gRGPHyGdUrVKgtr8epT5XU8WtNjk,8082
 dcicutils/trace_utils.py,sha256=g8kwV4ebEy5kXW6oOrEAUsurBcCROvwtZqz9fczsGRE,1769
 dcicutils/validation_utils.py,sha256=cMZIU2cY98FYtzK52z5WUYck7urH6JcqOuz9jkXpqzg,14797
 dcicutils/variant_utils.py,sha256=2H9azNx3xAj-MySg-uZ2SFqbWs4kZvf61JnK6b-h4Qw,4343
 dcicutils/zip_utils.py,sha256=0OXR0aLNwyLIZOzIFTM_5DOun7dxIv6TIZbFiithkO0,3276
-dcicutils-8.5.0.1b4.dist-info/LICENSE.txt,sha256=t0_-jIjqxNnymZoNJe-OltRIuuF8qfhN0ATlHyrUJPk,1102
-dcicutils-8.5.0.1b4.dist-info/METADATA,sha256=Zpf8fTsgsuRfo8WDGkONHxtcf4SPWOFK_4iCNVAhB78,3314
-dcicutils-8.5.0.1b4.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-dcicutils-8.5.0.1b4.dist-info/entry_points.txt,sha256=8wbw5csMIgBXhkwfgsgJeuFcoUc0WsucUxmOyml2aoA,209
-dcicutils-8.5.0.1b4.dist-info/RECORD,,
+dcicutils-8.5.0.1b7.dist-info/LICENSE.txt,sha256=t0_-jIjqxNnymZoNJe-OltRIuuF8qfhN0ATlHyrUJPk,1102
+dcicutils-8.5.0.1b7.dist-info/METADATA,sha256=AZPMmFxRxXIpn3-mhRMhuS3mHK9YFWjpsoA3T2TXo-g,3314
+dcicutils-8.5.0.1b7.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+dcicutils-8.5.0.1b7.dist-info/entry_points.txt,sha256=8wbw5csMIgBXhkwfgsgJeuFcoUc0WsucUxmOyml2aoA,209
+dcicutils-8.5.0.1b7.dist-info/RECORD,,