appmap 2.1.9__tar.gz → 2.2.0__tar.gz

appmap-2.2.0/.gitignore

@@ -0,0 +1,26 @@
+.envrc
+.tool-versions
+
+poetry.lock
+uv.lock
+
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+.python-version
+
+/dist/
+.venv/
+
+htmlcov/
+
+.vscode/
+
+/.tox
+/node_modules
+/ruff.toml
+
+appmap.log
+*.sqlite3

appmap-2.2.0/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: appmap
+Version: 2.2.0
+Summary: Create AppMap files by recording a Python application.
+Project-URL: Homepage, https://github.com/applandinc/appmap-python
+Author-email: Alan Potter <alan@app.land>, Viraj Kanwade <viraj.kanwade@forgeahead.io>, Rafał Rzepecki <rafal@app.land>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Flask
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Documentation
+Requires-Python: >=3.8
+Requires-Dist: importlib-resources>=5.4.0
+Requires-Dist: inflection>=0.3.0
+Requires-Dist: packaging>=19.0
+Requires-Dist: pyyaml>=5.3.0
+Provides-Extra: dev
+Requires-Dist: asgiref<4.0,>=3.7.2; extra == 'dev'
+Requires-Dist: black<25.0,>=24.2.0; extra == 'dev'
+Requires-Dist: coverage<6.0,>=5.3; extra == 'dev'
+Requires-Dist: django; extra == 'dev'
+Requires-Dist: fastapi<1.0,>=0.110.0; extra == 'dev'
+Requires-Dist: flake8<4.0,>=3.8.4; extra == 'dev'
+Requires-Dist: flask; extra == 'dev'
+Requires-Dist: httpretty<2.0,>=1.0.5; extra == 'dev'
+Requires-Dist: httpx<1.0,>=0.27.0; extra == 'dev'
+Requires-Dist: incremental<24.7.0; extra == 'dev'
+Requires-Dist: isort<6.0,>=5.10.1; extra == 'dev'
+Requires-Dist: numpy<2.0,>=1.24.4; (python_version < '3.9') and extra == 'dev'
+Requires-Dist: numpy>=2.0; (python_version >= '3.9') and extra == 'dev'
+Requires-Dist: pprintpp<1.0,>=0.4.0; extra == 'dev'
+Requires-Dist: psutil<7.0,>=6.0.0; extra == 'dev'
+Requires-Dist: pyfakefs<6.0,>=5.3.5; extra == 'dev'
+Requires-Dist: pylint<4.0,>=3.0; extra == 'dev'
+Requires-Dist: pytest-console-scripts<2.0,>=1.4.1; extra == 'dev'
+Requires-Dist: pytest-django<5.0,>=4.7; extra == 'dev'
+Requires-Dist: pytest-env<2.0,>=1.1.3; extra == 'dev'
+Requires-Dist: pytest-mock<4.0,>=3.5.1; extra == 'dev'
+Requires-Dist: pytest-randomly<4.0,>=3.5.0; extra == 'dev'
+Requires-Dist: pytest-shell-utilities<2.0,>=1.8.0; extra == 'dev'
+Requires-Dist: pytest-xdist<4.0,>=3.6.1; extra == 'dev'
+Requires-Dist: pytest-xprocess<1.0,>=0.23.0; extra == 'dev'
+Requires-Dist: pytest<8.0,>=7.3.2; extra == 'dev'
+Requires-Dist: python-decouple<4.0,>=3.5; extra == 'dev'
+Requires-Dist: requests<3.0,>=2.25.1; extra == 'dev'
+Requires-Dist: ruff<1.0,>=0.5.3; extra == 'dev'
+Requires-Dist: sqlalchemy; extra == 'dev'
+Requires-Dist: tox-gh-actions<4.0,>=3.0; extra == 'dev'
+Requires-Dist: tox-uv<2.0,>=1.0; extra == 'dev'
+Requires-Dist: tox<5.0,>=4.0; extra == 'dev'
+Requires-Dist: twisted<23.0,>=22.4.0; extra == 'dev'
+Requires-Dist: urllib3<2,>=1; extra == 'dev'
+Requires-Dist: uvicorn<1.0,>=0.27.1; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: asgiref<4.0,>=3.7.2; extra == 'test'
+Requires-Dist: django; extra == 'test'
+Requires-Dist: fastapi<1.0,>=0.110.0; extra == 'test'
+Requires-Dist: flask; extra == 'test'
+Requires-Dist: httpretty<2.0,>=1.0.5; extra == 'test'
+Requires-Dist: httpx<1.0,>=0.27.0; extra == 'test'
+Requires-Dist: incremental<24.7.0; extra == 'test'
+Requires-Dist: numpy<2.0,>=1.24.4; (python_version < '3.9') and extra == 'test'
+Requires-Dist: numpy>=2.0; (python_version >= '3.9') and extra == 'test'
+Requires-Dist: psutil<7.0,>=6.0.0; extra == 'test'
+Requires-Dist: pyfakefs<6.0,>=5.3.5; extra == 'test'
+Requires-Dist: pytest-console-scripts<2.0,>=1.4.1; extra == 'test'
+Requires-Dist: pytest-django<5.0,>=4.7; extra == 'test'
+Requires-Dist: pytest-env<2.0,>=1.1.3; extra == 'test'
+Requires-Dist: pytest-mock<4.0,>=3.5.1; extra == 'test'
+Requires-Dist: pytest-randomly<4.0,>=3.5.0; extra == 'test'
+Requires-Dist: pytest-shell-utilities<2.0,>=1.8.0; extra == 'test'
+Requires-Dist: pytest-xdist<4.0,>=3.6.1; extra == 'test'
+Requires-Dist: pytest-xprocess<1.0,>=0.23.0; extra == 'test'
+Requires-Dist: pytest<8.0,>=7.3.2; extra == 'test'
+Requires-Dist: python-decouple<4.0,>=3.5; extra == 'test'
+Requires-Dist: requests<3.0,>=2.25.1; extra == 'test'
+Requires-Dist: sqlalchemy; extra == 'test'
+Requires-Dist: twisted<23.0,>=22.4.0; extra == 'test'
+Requires-Dist: urllib3<2,>=1; extra == 'test'
+Requires-Dist: uvicorn<1.0,>=0.27.1; extra == 'test'
+Description-Content-Type: text/markdown
+
+- [About](#about)
+- [Usage](#usage)
+- [Development](#development)
+  - [Getting the code](#getting-the-code)
+  - [Python version support](#python-version-support)
+  - [Dependency management](#dependency-management)
+    - [wrapt](#wrapt)
+  - [Linting](#linting)
+  - [Testing](#testing)
+    - [pytest](#pytest)
+    - [tox](#tox)
+  - [Code Coverage](#code-coverage)
+
+# About
+`appmap-python` is a Python package for recording
+[AppMaps](https://github.com/applandinc/appmap) of your code. "AppMap" is a data format
+which records code structure (modules, classes, and methods), code execution events
+(function calls and returns), and code metadata (repo name, repo URL, commit SHA, labels,
+etc). It's more granular than a performance profile, but it's less granular than a full
+debug trace. It's designed to be optimal for understanding the design intent and structure
+of code and key data flows.
+
+# Usage
+
+Visit the [AppMap for Python](https://appland.com/docs/reference/appmap-python.html) reference page on AppLand.com for a complete reference guide.
+
+# Development
+
+[![Build Status](https://travis-ci.com/getappmap/appmap-python.svg?branch=master)](https://travis-ci.com/getappmap/appmap-python)
+
+## Getting the code
+Clone the repo to begin development.
+
+```shell
+% git clone https://github.com/applandinc/appmap-python.git
+Cloning into 'appmap-python'...
+remote: Enumerating objects: 167, done.
+remote: Counting objects: 100% (167/167), done.
+remote: Compressing objects: 100% (100/100), done.
+remote: Total 962 (delta 95), reused 116 (delta 61), pack-reused 795
+Receiving objects: 100% (962/962), 217.31 KiB | 4.62 MiB/s, done.
+Resolving deltas: 100% (653/653), done.
+```
+
+## Python version support
+As a package intended to be installed in as many environments as possible, `appmap-python`
+needs to avoid using features of Python or the standard library that were added after the
+oldest version currently supported (see the
+[supported versions](https://appland.com/docs/reference/appmap-python.html#supported-versions)).
+
+## Dependency management
+
+[uv](https://docs.astral.sh/uv/) is used for dependency management and provides fast package installation:
+
+```bash
+# Install uv (macOS/Linux)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Install dependencies
+cd appmap-python
+uv sync --all-extras
+```
+
+### wrapt
+The one dependency that is not managed using `uv` is `wrapt`. Because it's possible that
+projects that use `appmap` may also need an unmodified version of `wrapt` (e.g. `pylint` depends on
+`astroid`, which in turn depends on `wrapt`), we use
+[vendoring](https://github.com/pradyunsg/vendoring) to vendor `wrapt`.
+
+To update `wrapt`, use `tox` (described below) to run the `vendoring` environment.
+
+## Linting
+[pylint](https://www.pylint.org/) for linting:
+
+```bash
+cd appmap-python
+uv run tox -e lint
+
+# Or run pylint directly
+uv run pylint appmap
+
+--------------------------------------------------------------------
+Your code has been rated at 10.00/10 (previous run: 10.00/10, +0.00)
+```
+
+
+## Testing
+### pytest
+
+[pytest](https://docs.pytest.org/en/stable/) for testing:
+
+```bash
+cd appmap-python
+
+# Run all tests
+APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest
+
+# Run tests with a specific Python version
+APPMAP_DISPLAY_PARAMS=true uv run --python 3.9 appmap-python pytest
+
+# Run tests in parallel
+APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest -n auto
+```
+
+### tox
+The `tox` configuration provides the ability to run the tests for all supported versions of Python and web frameworks (Django, Flask, SQLAlchemy).
+
+With `uv`, you don't need to pre-install Python versions - `uv` will automatically download and manage them:
+
+```bash
+cd appmap-python
+
+# Run full test matrix (all Python versions and frameworks)
+uv run tox
+
+# Run tests for a specific Python version
+uv run tox -e py312-web
+
+# Run tests for specific framework
+uv run tox -e py312-django5
+
+# Update vendored wrapt dependency
+uv run tox -e vendoring sync
+```
+
+## Code Coverage
+[coverage](https://coverage.readthedocs.io/) for coverage:
+
+```bash
+cd appmap-python
+uv run coverage run -m pytest
+uv run coverage html
+open htmlcov/index.html
+```

{appmap-2.1.9 → appmap-2.2.0}/README.md

@@ -50,16 +50,19 @@ oldest version currently supported (see the
 
 ## Dependency management
 
-[poetry](https://https://python-poetry.org/) for dependency management:
+[uv](https://docs.astral.sh/uv/) is used for dependency management and provides fast package installation:
 
-```
-% brew install poetry
-% cd appmap-python
-% poetry install
+```bash
+# Install uv (macOS/Linux)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Install dependencies
+cd appmap-python
+uv sync --all-extras
 ```
 
 ### wrapt
-The one dependency that is not managed using `poetry` is `wrapt`. Because it's possible that
+The one dependency that is not managed using `uv` is `wrapt`. Because it's possible that
 projects that use `appmap` may also need an unmodified version of `wrapt` (e.g. `pylint` depends on
 `astroid`, which in turn depends on `wrapt`), we use
 [vendoring](https://github.com/pradyunsg/vendoring) to vendor `wrapt`.
@@ -69,64 +72,63 @@ To update `wrapt`, use `tox` (described below) to run the `vendoring` environmen
 ## Linting
 [pylint](https://www.pylint.org/) for linting:
 
-```
-% cd appmap-python
-% poetry run pylint appmap
+```bash
+cd appmap-python
+uv run tox -e lint
+
+# Or run pylint directly
+uv run pylint appmap
 
 --------------------------------------------------------------------
 Your code has been rated at 10.00/10 (previous run: 10.00/10, +0.00)
-
 ```
 
-[Note that the current configuration has a threshold set which must be met for the Travis build to
-pass. To make this easier to achieve, a number of checks have both been disabled. They should be
-reenabled as soon as possible.]
-
 
 ## Testing
 ### pytest
 
-Note that you must install the dependencies contained in
-[requirements-dev.txt](requirements-dev.txt) before running tests. See the explanation in
-[pyproject.toml](pyproject.toml) for details.
+[pytest](https://docs.pytest.org/en/stable/) for testing:
 
-Additionally, the tests currently require that you set `APPMAP=true` and
-`APPMAP_DISPLAY_PARAMS=true`. 
+```bash
+cd appmap-python
 
-[pytest](https://docs.pytest.org/en/stable/) for testing:
+# Run all tests
+APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest
 
-```
-% cd appmap-python
-% pip install -r requirements-test.txt
-% APPMAP=true APPMAP_DISPLAY_PARAMS=true poetry run pytest
+# Run tests with a specific Python version
+APPMAP_DISPLAY_PARAMS=true uv run --python 3.9 appmap-python pytest
+
+# Run tests in parallel
+APPMAP_DISPLAY_PARAMS=true uv run appmap-python pytest -n auto
 ```
 
 ### tox
-Additionally, the `tox` configuration provides the ability to run the tests for all
-supported versions of Python and Django.
+The `tox` configuration provides the ability to run the tests for all supported versions of Python and web frameworks (Django, Flask, SQLAlchemy).
 
-`tox` requires that all the correct versions of Python to be available to create
-the test environments. [pyenv](https://github.com/pyenv/pyenv) is an easy way to manage
-multiple versions of Python, and the [xxenv-latest
-plugin](https://github.com/momo-lab/xxenv-latest) can help get all the latest versions.
+With `uv`, you don't need to pre-install Python versions - `uv` will automatically download and manage them:
 
+```bash
+cd appmap-python
 
+# Run full test matrix (all Python versions and frameworks)
+uv run tox
 
-```sh
-% brew install pyenv
-% git clone https://github.com/momo-lab/xxenv-latest.git "$(pyenv root)"/plugins/xxenv-latest
-% cd appmap-python
-% pyenv latest local 3.{9,6,7,8}
-% for v in 3.{9,6,7,8}; do pyenv latest install $v; done
-% poetry run tox
+# Run tests for a specific Python version
+uv run tox -e py312-web
+
+# Run tests for specific framework
+uv run tox -e py312-django5
+
+# Update vendored wrapt dependency
+uv run tox -e vendoring sync
 ```
 
 ## Code Coverage
 [coverage](https://coverage.readthedocs.io/) for coverage:
 
-```
-% cd appmap-python
-% poetry run coverage run -m pytest
-% poetry run coverage html
-% open htmlcov/index.html
+```bash
+cd appmap-python
+uv run coverage run -m pytest
+uv run coverage html
+open htmlcov/index.html
 ```

{appmap-2.1.9 → appmap-2.2.0}/_appmap/env.py

@@ -45,8 +45,16 @@ class Env(metaclass=SingletonMeta):
         # them.
         enabled = self._env.get("_APPMAP", None)
         self._enabled = enabled is not None and enabled.lower() != "false"
-        display_params = self._env.get("_APPMAP_DISPLAY_PARAMS", None)
-        self._display_params = display_params is not None and display_params.lower() != "false"
+        display_params = self._env.get("_APPMAP_DISPLAY_PARAMS", "labeled").lower()
+        if display_params == "true":
+            self._display_params = True
+            self._display_labeled_params = True
+        elif display_params == "false":
+            self._display_params = False
+            self._display_labeled_params = False
+        else: # "labeled" or "auto" or anything else defaults to labeled
+            self._display_params = False
+            self._display_labeled_params = True
 
         logger = logging.getLogger(__name__)
         # The user shouldn't set APPMAP_OUTPUT_DIR, but some tests depend on being able to use it.
@@ -134,6 +142,10 @@ class Env(metaclass=SingletonMeta):
     def display_params(self):
         return self._display_params
 
+    @property
+    def display_labeled_params(self):
+        return self._display_labeled_params
+
     def getLogger(self, name) -> trace_logger.TraceLogger:
         return cast(trace_logger.TraceLogger, logging.getLogger(name))
 

{appmap-2.1.9 → appmap-2.2.0}/_appmap/event.py

@@ -45,13 +45,13 @@ class _EventIds:
         cls._next_thread_id = 0
 
 
-def display_string(val):
+def display_string(val, display_value=False):
     # If we're asked to display parameters, make a best-effort attempt
     # to get a string value for the parameter using repr(). If parameter
     # display is disabled, or repr() has raised, just formulate a value
     # from the class and id.
     value = None
-    if Env.current.display_params:
+    if display_value:
         try:
             value = repr(val)
         except Exception:  # pylint: disable=broad-except
@@ -79,7 +79,7 @@ def _is_list_or_dict(val_type):
     return issubclass(val_type, list), issubclass(val_type, dict)
 
 
-def _describe_schema(name, val, depth, max_depth):
+def _describe_schema(name, val, depth, max_depth, display_value=False):
 
     val_type = type(val)
 
@@ -88,6 +88,9 @@ def _describe_schema(name, val, depth, max_depth):
         ret["name"] = name
     ret["class"] = fqname(val_type)
 
+    if not display_value:
+        return ret
+
     islist, isdict = _is_list_or_dict(val_type)
     if not (islist or isdict) or (depth >= max_depth and isdict):
         return ret
@@ -100,7 +103,10 @@ def _describe_schema(name, val, depth, max_depth):
         elts = val.items()
         schema_key = "properties"
 
-    schema = [_describe_schema(k, v, depth + 1, max_depth) for k, v in elts]
+    schema = [
+        _describe_schema(k, v, depth + 1, max_depth, display_value=display_value)
+        for k, v in elts
+    ]
     # schema will be [None] if depth is exceeded, don't use it
     if any(schema):
         ret[schema_key] = schema
@@ -108,15 +114,14 @@ def _describe_schema(name, val, depth, max_depth):
     return ret
 
 
-def describe_value(name, val, max_depth=5):
-    ret = {
+def describe_value(name, val, max_depth=5, display_value=False):
+    ret = _describe_schema(name, val, 0, max_depth, display_value=display_value)
+    ret.update({
         "object_id": id(val),
-        "value": display_string(val),
-    }
-    if Env.current.display_params:
-        ret.update(_describe_schema(name, val, 0, max_depth))
+        "value": display_string(val, display_value=display_value),
+    })
 
-    if any(_is_list_or_dict(type(val))):
+    if display_value and any(_is_list_or_dict(type(val))):
         ret["size"] = len(val)
 
     return ret
@@ -170,9 +175,9 @@ class Param:
     def __repr__(self):
         return "<Param name: %s kind: %s>" % (self.name, self.kind)
 
-    def to_dict(self, value):
+    def to_dict(self, value, display_value=False):
         ret = {"kind": self.kind}
-        ret.update(describe_value(self.name, value))
+        ret.update(describe_value(self.name, value, display_value=display_value))
         return ret
 
 def _get_name_parts(filterable):
@@ -247,7 +252,7 @@ class CallEvent(Event):
         return [Param(p) for p in sig.parameters.values()]
 
     @staticmethod
-    def set_params(params, instance, args, kwargs):
+    def set_params(params, instance, args, kwargs, display_value=False):
         # pylint: disable=too-many-branches
         # Note that set_params expects args and kwargs as a tuple and
         # dict, respectively. It operates on them as collections, so
@@ -295,7 +300,7 @@ class CallEvent(Event):
                 # If all the parameter types are handled, this
                 # shouldn't ever happen...
                 raise RuntimeError("Unknown parameter with desc %s" % (repr(p)))
-            ret.append(p.to_dict(value))
+            ret.append(p.to_dict(value, display_value=display_value))
         return ret
 
     @property
@@ -405,8 +410,9 @@ class MessageEvent(Event):  # pylint: disable=too-few-public-methods
 
     @message_parameters.setter
     def message_parameters(self, params):
+        display_params = Env.current.display_params
         for name, value in params.items():
-            message_object = describe_value(name, value)
+            message_object = describe_value(name, value, display_value=display_params)
             self.message.append(message_object)
 
 
@@ -497,13 +503,13 @@ class ReturnEvent(Event):
 class FuncReturnEvent(ReturnEvent):
     __slots__ = ["return_value"]
 
-    def __init__(self, parent_id, elapsed, return_value):
+    def __init__(self, parent_id, elapsed, return_value, display_value=False):
         super().__init__(parent_id, elapsed)
         # Import here to prevent circular dependency
         # pylint: disable=import-outside-toplevel
         from _appmap.instrument import recording_disabled # noqa: F401
         with recording_disabled():
-            self.return_value = describe_value(None, return_value)
+            self.return_value = describe_value(None, return_value, display_value=display_value)
 
 
 class HttpResponseEvent(ReturnEvent):

{appmap-2.1.9 → appmap-2.2.0}/_appmap/instrument.py

@@ -70,7 +70,7 @@ def saved_shallow_rule():
 
 
 _InstrumentedFn = namedtuple(
-    "_InstrumentedFn", "fn fntype instrumented_fn make_call_event params"
+    "_InstrumentedFn", "fn fntype instrumented_fn make_call_event params display_params"
 )
 
 
@@ -84,7 +84,9 @@ def call_instrumented(f, instance, args, kwargs):
 
     with recording_disabled():
         logger.trace("%s args %s kwargs %s", f.fn, args, kwargs)
-        params = CallEvent.set_params(f.params, instance, args, kwargs)
+        params = CallEvent.set_params(
+            f.params, instance, args, kwargs, display_value=f.display_params
+        )
         call_event = f.make_call_event(parameters=params)
     Recorder.add_event(call_event)
     call_event_id = call_event.id
@@ -95,7 +97,8 @@ def call_instrumented(f, instance, args, kwargs):
         elapsed_time = time.time() - start_time
 
         return_event = event.FuncReturnEvent(
-            return_value=ret, parent_id=call_event_id, elapsed=elapsed_time
+            return_value=ret, parent_id=call_event_id, elapsed=elapsed_time,
+            display_value=f.display_params
         )
         Recorder.add_event(return_event)
         return ret
@@ -120,9 +123,16 @@ def instrument(filterable):
     """return an instrumented function"""
     logger.debug("hooking %s", filterable.fqname)
 
+    # note this has to happen before CallEvent.make, which clears this attribute
+    has_labels = hasattr(filterable.obj, "_appmap_labels")
+
     make_call_event = event.CallEvent.make(filterable)
     params = CallEvent.make_params(filterable)
 
+    display_params = Env.current.display_params or (
+        has_labels and Env.current.display_labeled_params
+    )
+
     # django depends on being able to find the cache_clear attribute
     # on functions. (You can see this by trying to map
     # https://github.com/chicagopython/chypi.org.) Make sure it gets
@@ -132,7 +142,8 @@ def instrument(filterable):
     def instrumented_fn(wrapped, instance, args, kwargs):
         with saved_shallow_rule():
             f = _InstrumentedFn(
-                wrapped, filterable.fntype, instrumented_fn, make_call_event, params
+                wrapped, filterable.fntype, instrumented_fn, make_call_event, params,
+                display_params
             )
             return call_instrumented(f, instance, args, kwargs)
 

{appmap-2.1.9 → appmap-2.2.0}/_appmap/test/data/example_class.py

@@ -56,6 +56,10 @@ class ExampleClass(Super, ClassMethodMixin):
     def labeled_method(self):
         return "super important"
 
+    @appmap.labels("super", "important")
+    def labeled_method_with_param(self, p):
+        return p
+
     @staticmethod
     @wrap_fn
     def wrapped_static_method():

appmap-2.2.0/_appmap/test/data/pytest/expected/status_xsucceeded.metadata.json

@@ -0,0 +1 @@
+../../unittest/expected/status_xsucceeded.metadata.json

{appmap-2.1.9 → appmap-2.2.0}/_appmap/test/test_describe_value.py

@@ -24,7 +24,7 @@ class TestDictValue:
         return {"id": 1, "contents": "some text"}
 
     def test_one_level_schema(self, value):
-        actual = describe_value(None, value)
+        actual = describe_value(None, value, display_value=True)
         assert actual == DictIncluding(
             {
                 "properties": [
@@ -34,6 +34,13 @@ class TestDictValue:
             }
         )
 
+    def test_one_level_schema_display_false(self, value):
+        actual = describe_value(None, value, display_value=False)
+        assert "properties" not in actual
+        assert actual["class"] == "builtins.dict"
+        assert "builtins.dict object at" in actual["value"]
+        assert actual["object_id"] == id(value)
+
 
 class TestNestedDictValue:
     @pytest.fixture
@@ -41,7 +48,7 @@ class TestNestedDictValue:
         return {"page": {"page_number": 1, "page_size": 20, "total": 2383}}
 
     def test_two_level_schema(self, value):
-        actual = describe_value(None, value)
+        actual = describe_value(None, value, display_value=True)
         assert actual == DictIncluding(
             {
                 "properties": [
@@ -60,7 +67,7 @@ class TestNestedDictValue:
 
     def test_respects_max_depth(self, value):
         expected = {"properties": [{"name": "page", "class": "builtins.dict"}]}
-        actual = describe_value(None, value, max_depth=1)
+        actual = describe_value(None, value, max_depth=1, display_value=True)
         assert actual == DictIncluding(expected)
 
 
@@ -70,7 +77,7 @@ class TestListOfDicts:
         return [{"id": 1, "contents": "some text"}, {"id": 2}]
 
     def test_an_array_containing_schema(self, value):
-        actual = describe_value(None, value)
+        actual = describe_value(None, value, display_value=True)
         assert actual["class"] == "builtins.list"
         assert actual["items"][0] == DictIncluding(
             {
@@ -88,6 +95,13 @@ class TestListOfDicts:
             }
         )
 
+    def test_an_array_display_false(self, value):
+        actual = describe_value(None, value, display_value=False)
+        assert "items" not in actual
+        assert actual["class"] == "builtins.list"
+        assert "builtins.list object at" in actual["value"]
+        assert actual["object_id"] == id(value)
+
 
 class TestNestedArrays:
     @pytest.fixture
@@ -95,7 +109,7 @@ class TestNestedArrays:
         return [[["one"]]]
 
     def test_arrays_ignore_max_depth(self, value):
-        actual = describe_value(None, value, max_depth=1)
+        actual = describe_value(None, value, max_depth=1, display_value=True)
         expected = {
             "class": "builtins.list",
             "items": [