ucfopen__canvasapi-716

The user wants to fix a bug in `obj_or_str` in `canvasapi`.
The problem is that `obj_or_str` improperly rejects strings, whereas `obj_or_id` handles them correctly.
`obj_or_str` is used in several places related to `FeatureFlag`.

Let's start by locating `obj_or_id` and `obj_or_str`. They are likely in `canvasapi/util.py` based on the workspace layout.

I'll search for them first.

{
  "command": "grep -rn --include=\"*.py\" \"def obj_or_id\" . && grep -rn --include=\"*.py\" \"def obj_or_str\" ."
}

{
  "status": "ok",
  "stdout": "./canvasapi/util.py:101:def obj_or_id(parameter, param_name, object_types):\n./canvasapi/util.py:136:def obj_or_str(obj, attr, object_types):\n",
  "stderr": "",
  "exit_code": 0
}

Okay, both are in `canvasapi/util.py`. Let's examine their implementations.

{
  "end_line": 150,
  "filepath": "canvasapi/util.py",
  "start_line": 100
}

{
  "status": "ok",
  "filepath": "canvasapi/util.py",
  "content": "\ndef obj_or_id(parameter, param_name, object_types):\n    \"\"\"\n    Accepts either an int (or long or str representation of an integer)\n    or an object. If it is an int, return it. If it is an object and\n    the object is of correct type, return the object's id. Otherwise,\n    throw an exception.\n\n    :param parameter: int, str, long, or object\n    :param param_name: str\n    :param object_types: tuple\n    :rtype: int\n    \"\"\"\n    from canvasapi.user import User\n\n    try:\n        return int(parameter)\n    except (ValueError, TypeError):\n        # Special case where 'self' is a valid ID of a User object\n        if User in object_types and parameter == \"self\":\n            return parameter\n\n        for obj_type in object_types:\n            if isinstance(parameter, obj_type):\n                try:\n                    return int(parameter.id)\n                except Exception:\n                    break\n\n        obj_type_list = \",\".join([obj_type.__name__ for obj_type in object_types])\n        message = \"Parameter {} must be of type {} or int.\".format(\n            param_name, obj_type_list\n        )\n        raise TypeError(message)\n\n\ndef obj_or_str(obj, attr, object_types):\n    \"\"\"\n    Accepts an object. If the object has the attribute, return the\n    corresponding string. Otherwise, throw an exception.\n\n    :param obj: object from which to retrieve attribute\n    :type obj: object\n    :param attr: name of the attribute to retrieve\n    :type attr: str\n    :param object_types: tuple containing the types of the object being passed in\n    :type object_types: tuple\n    :rtype: str\n    \"\"\"\n    try:\n        return str(getattr(obj, attr))",
  "start_line": 100,
  "end_line": 150,
  "total_lines": 244,
  "is_truncated": false
}

Wait, the `read_file` output for `obj_or_str` is truncated at the end of the `try` block. Let me read more of `obj_or_str`.

{
  "end_line": 160,
  "filepath": "canvasapi/util.py",
  "start_line": 136
}

{
  "status": "ok",
  "filepath": "canvasapi/util.py",
  "content": "def obj_or_str(obj, attr, object_types):\n    \"\"\"\n    Accepts an object. If the object has the attribute, return the\n    corresponding string. Otherwise, throw an exception.\n\n    :param obj: object from which to retrieve attribute\n    :type obj: object\n    :param attr: name of the attribute to retrieve\n    :type attr: str\n    :param object_types: tuple containing the types of the object being passed in\n    :type object_types: tuple\n    :rtype: str\n    \"\"\"\n    try:\n        return str(getattr(obj, attr))\n    except (AttributeError, TypeError):\n        if not isinstance(attr, str):\n            raise TypeError(\n                \"Atttibute parameter {} must be of type string\".format(attr)\n            )\n        for obj_type in object_types:\n            if isinstance(obj, obj_type):\n                try:\n                    return str(getattr(obj, attr))\n                except AttributeError:",
  "start_line": 136,
  "end_line": 160,
  "total_lines": 244,
  "is_truncated": false
}

Wait, I need more of it.

{
  "end_line": 170,
  "filepath": "canvasapi/util.py",
  "start_line": 155
}

{
  "status": "ok",
  "filepath": "canvasapi/util.py",
  "content": "            )\n        for obj_type in object_types:\n            if isinstance(obj, obj_type):\n                try:\n                    return str(getattr(obj, attr))\n                except AttributeError:\n                    raise AttributeError(\"{} object does not have {} attribute\").format(\n                        obj, attr\n                    )\n\n        obj_type_list = \",\".join([obj_type.__name__ for obj_type in object_types])\n        raise TypeError(\"Parameter {} must be of type {}.\".format(obj, obj_type_list))\n\n\ndef get_institution_url(base_url):\n    \"\"\"",
  "start_line": 155,
  "end_line": 170,
  "total_lines": 244,
  "is_truncated": false
}

Let me re-examine `obj_or_str`'s logic.

```python
def obj_or_str(obj, attr, object_types):
    """
    Accepts an object. If the object has the attribute, return the
    corresponding string. Otherwise, throw an exception.

    :param obj: object from which to retrieve attribute
    :type obj: object
    :param attr: name of the attribute to retrieve
    :type attr: str
    :param object_types: tuple containing the types of the object being passed in
    :type object_types: tuple
    :rtype: str
    """
    try:
        return str(getattr(obj, attr))
    except (AttributeError, TypeError):
        if not isinstance(attr, str):
            raise TypeError(
                "Atttibute parameter {} must be of type string".format(attr)
            )
        for obj_type in object_types:
            if isinstance(obj, obj_type):
                try:
                    return str(getattr(obj, attr))
                except AttributeError:
                    raise AttributeError("{} object does not have {} attribute").format(
                        obj, attr
                    )

        obj_type_list = ",".join([obj_type.__name__ for obj_type in object_types])
        raise TypeError("Parameter {} must be of type {}.\".format(obj, obj_type_list))
```

Wait, if `obj` is already a string, `getattr(obj, attr)` will likely fail with `AttributeError` (unless `attr` is a string method). Then it goes to the `except` block.
It checks `isinstance(attr, str)`. `attr` is supposed to be the attribute name (e.g. 'id'), so it is a string.
Then it iterates through `object_types`. If `obj` is a string, and `str` is NOT in `object_types`, it will raise `TypeError`.

The goal is for `obj_or_str` to be more like `obj_or_id`.
`obj_or_id` does:
```python
    try:
        return int(parameter)
    except (ValueError, TypeError):
        ...
```
So if `parameter` is already an `int`, it returns it.

For `obj_or_str`, if `obj` is already a string, it should probably just return it.

Let's verify this hypothesis. If `obj` is a string, `obj_or_str(obj, attr, object_types)` should return `obj`.

Let's check the usage of `obj_or_str` in the mentioned files:
- `canvasapi.account.Account.get_feature_flag()`
- `canvasapi.course.Course.get_feature_flag()`
- `canvasapi.feature.FeatureFlag.delete()`
- `canvasapi.feature.FeatureFlag.set_feature_flag()`
- `canvasapi.user.User.get_feature_flag()`

Let's see how it's called in `canvasapi/feature.py` specifically for `FeatureFlag.delete` and `FeatureFlag.set_feature_flag`.

{
  "filepath": "canvasapi/feature.py"
}

{
  "status": "ok",
  "filepath": "canvasapi/feature.py",
  "content": "from canvasapi.canvas_object import CanvasObject\nfrom canvasapi.util import combine_kwargs, obj_or_str\n\n\nclass Feature(CanvasObject):\n    def __str__(self):\n        return \"{} {}\".format(self.display_name, self.applies_to)\n\n    @property\n    def _parent_id(self):\n        \"\"\"\n        Return the id of the account, course or user that spawned this feature\n\n        :rtype: int\n        \"\"\"\n        if hasattr(self, \"account_id\"):\n            return self.account_id\n        elif hasattr(self, \"course_id\"):\n            return self.course_id\n        elif hasattr(self, \"user_id\"):\n            return self.user_id\n        else:\n            raise ValueError(\n                \"Feature Flag does not have account_id, course_id or user_id\"\n            )\n\n    @property\n    def _parent_type(self):\n        \"\"\"\n        Return whether the feature with the feature was spawned from an account,\n        a course or a user.\n\n        :rtype: str\n        \"\"\"\n        if hasattr(self, \"account_id\"):\n            return \"account\"\n        elif hasattr(self, \"course_id\"):\n            return \"course\"\n        elif hasattr(self, \"user_id\"):\n            return \"user\"\n        else:\n            raise ValueError(\n                \"Feature Flag does not have account_id, course_id or user_id\"\n            )\n\n\nclass FeatureFlag(CanvasObject):\n    def __str__(self):\n        return \"{} {} {} {}\".format(\n            self.context_type, self.context_id, self.feature, self.state\n        )\n\n    def delete(self, feature, **kwargs):\n        \"\"\"\n        Remove a feature flag for a given account, course or user.\n\n        :calls: `DELETE /api/v1/courses/:course_id/features/flags/:feature \\\n            <https://canvas.instructure.com/doc/api/\n            feature_flags.html#method.feature_flags.delete>`_\n\n            or `DELETE /api/v1/accounts/:account_id/features/flags/:feature \\\n            <https://canvas.instructure.com/doc/api/\n            feature_flags.html#method.feature_flags.delete>`_\n\n            or `DELETE /api/v1/users/:user_id/features/flags/:feature \\\n            <https://canvas.instructure.com/doc/api/\n            feature_flags.html#method.feature_flags.delete>`_\n\n        :rtype: :class:`canvasapi.feature.FeatureFlag`\n        \"\"\"\n        feature_name = obj_or_str(feature, \"name\", (Feature,))\n\n        response = self._requester.request(\n            \"DELETE\",\n            \"{}s/{}/features/flags/{}\".format(\n                feature._parent_type, feature._parent_id, feature_name\n            ),\n            _kwargs=combine_kwargs(**kwargs),\n        )\n        return FeatureFlag(self._requester, response.json())\n\n    def set_feature_flag(self, feature, **kwargs):\n        \"\"\"\n        Set a feature flag for a given account, course or user.\n\n        :calls: `PUT /api/v1/courses/:course_id/features/flags/:feature \\\n            <https://canvas.instructure.com/doc/api/\n            feature_flags.html#method.feature_flags.update>`_\n\n            or `PUT /api/v1/accounts/:account_id/features/flags/:feature \\\n            <https://canvas.instructure.com/doc/api/\n            feature_flags.html#method.feature_flags.update>`_\n\n            or `PUT /api/v1/users/:user_id/features/flags/:feature \\\n            <https://canvas.instructure.com/doc/api/\n            feature_flags.html#method.feature_flags.update>`_\n\n        :param feature: The feature object to set\n        :type feature: :class:`canvasapi.feature.Feature`\n\n        :rtype: :class:`canvasapi.feature.FeatureFlag`\n        \"\"\"\n        feature_name = obj_or_str(feature, \"name\", (Feature,))\n\n        response = self._requester.request(\n            \"PUT\",\n            \"{}s/{}/features/flags/{}\".format(\n                feature._parent_type, feature._parent_id, feature_name\n            ),\n            _kwargs=combine_kwargs(**kwargs),\n        )\n        return FeatureFlag(self._requester, response.json())",
  "start_line": 1,
  "end_line": 112,
  "total_lines": 112,
  "is_truncated": false
}

Wait, `FeatureFlag.delete` and `set_feature_flag` have a bugs that I just noticed:

```python
    def delete(self, feature, **kwargs):
        ...
        feature_name = obj_or_str(feature, "name", (Feature,))

        response = self._requester.request(
            "DELETE",
            "{}s/{}/features/flags/{}\".format(
                feature._parent_type, feature._parent_id, feature_name
            ),
```

If `feature` is a string, `feature_name` will be that string (once we fix `obj_or_str`). But then `feature._parent_type` and `feature._parent_id` will fail because `feature` is a string and doesn't have those attributes.

However, the problem statement only asks to fix `obj_or_str`. Let's focus on that first.
Wait, looking at `FeatureFlag.delete` again:
```python
        feature_name = obj_or_str(feature, "name", (Feature,))

        response = self._requester.request(
            "DELETE",
            "{}s/{}/features/flags/{}\".format(
                feature._parent_type, feature._parent_id, feature_name
            ),
```
Actually, `feature` is passed to `obj_or_str`. If `feature` is a `Feature` object, `feature_name` is `feature.name`. But then it uses `feature._parent_type` and `feature._parent_id`.
If `feature` is a string, it'll fail because `feature` used as an object.

But let's look at `obj_or_id` again:
```python
def obj_or_id(parameter, param_name, object_types):
    ...
    try:
        return int(parameter)
    except (ValueError, TypeError):
        ...
```
It returns the ID and doesn't use the original `parameter` later.

In `FeatureFlag.delete`:
```python
        feature_name = obj_or_str(feature, "name", (Feature,))

        response = self._requester.request(
            "DELETE",
            "{}s/{}/features/flags/{}\".format(
                feature._parent_type, feature._parent_id, feature_name
            ),
```
It uses BOTH `feature_name` (the result of `obj_or_str`) AND `feature` (the original object).
If `feature` was intended to be either a `Feature` object or a string, then the caller probably expects `feature` to be a `Feature` object because it accesses `_parent_type` and `_parent_id`.
Wait, `FeatureFlag` itself has the context. Maybe it should use its own context?
Let's look at `FeatureFlag` definition. It's a `CanvasObject`.
`FeatureFlag` inherited from `CanvasObject`.

Wait, `FeatureFlag` has `context_type` and `context_id` in its `__str__` method:
```python
    def __str__(self):
        return "{} {} {} {}".format(
            self.context_type, self.context_id, self.feature, self.state
        )
```
So it probably has `context_type` and `context_id`.

But anyway, the task is explicitly about `obj_or_str`.

Let's write a reproduction script for `obj_or_str` to show it rejects strings.

{
  "command": "python3 - <<'PY'\nfrom canvasapi.util import obj_or_str\n\nclass MockFeature:\n    def __init__(self, name):\n        self.name = name\n\nfeature_obj = MockFeature(\"my_feature\")\n# Should work\nprint(f\"Object: {obj_or_str(feature_obj, 'name', (MockFeature,))}\")\n\n# Should work (once fixed) but currently likely fails\ntry:\n    print(f\"String: {obj_or_str('my_feature', 'name', (MockFeature,))}\")\nexcept Exception as e:\n    print(f\"String failed: {type(e).__name__}: {e}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Object: my_feature\nString failed: TypeError: Parameter my_feature must be of type MockFeature.\n",
  "stderr": "",
  "exit_code": 0
}

Confirmed. `obj_or_str` rejects strings.

Now let's see how to make it more like `obj_or_id`.
`obj_or_id` does `return int(parameter)` first.
So `obj_or_str` should do `if isinstance(obj, str): return obj` first.

Wait, if I just do `if isinstance(obj, str): return obj`, what if `obj` is something that can be cast to string but shouldn't be?
`obj_or_id` uses `int(parameter)`.
`obj_or_str` could use `if isinstance(obj, str): return obj`.

Let's see `obj_or_id` again.
```python
def obj_or_id(parameter, param_name, object_types):
    ...
    try:
        return int(parameter)
    except (ValueError, TypeError):
```
If `parameter` is a string that looks like an int, it returns it as an int.
If it's already an int, it returns it.
If it's an object, it fails the `int()` cast and then checks `object_types`.

For `obj_or_str`, if the user passes a string, they probably want that string to be used as the "name" (the attribute we are looking for).

So we should add a check at the beginning of `obj_or_str` to see if `obj` is already a string.

```python
def obj_or_str(obj, attr, object_types):
    if isinstance(obj, str):
        return obj
    try:
        return str(getattr(obj, attr))
    ...
```

Wait, let's check if `obj_or_id` does anything else.
It has a special case for `User` and `"self"`.
```python
        # Special case where 'self' is a valid ID of a User object
        if User in object_types and parameter == "self":
            return parameter
```
Does `obj_or_str` need any such special case? Probably not, unless specified. The problem statement says "Update `obj_or_str` to be more in line with `obj_or_id`".

Let's check the implementation of `obj_or_str` again.

```python
def obj_or_str(obj, attr, object_types):
    """
    Accepts an object. If the object has the attribute, return the
    corresponding string. Otherwise, throw an exception.

    :param obj: object from which to retrieve attribute
    :type obj: object
    :param attr: name of the attribute to retrieve
    :type attr: str
    :param object_types: tuple containing the types of the object being passed in
    :type object_types: tuple
    :rtype: str
    """
    try:
        return str(getattr(obj, attr))
    except (AttributeError, TypeError):
        if not isinstance(attr, str):
            raise TypeError(
                "Atttibute parameter {} must be of type string".format(attr)
            )
        for obj_type in object_types:
            if isinstance(obj, obj_type):
                try:
                    return str(getattr(obj, attr))
                except AttributeError:
                    raise AttributeError("{} object does not have {} attribute").format(
                        obj, attr
                    )

        obj_type_list = ",".join([obj_type.__name__ for obj_type in object_types])
        raise TypeError("Parameter {} must be of type {}.\".format(obj, obj_type_list))
```

There's a bug in the original code:
`raise AttributeError("{} object does not have {} attribute").format(obj, attr)`
`.format()` is called on the exception class/instance, but it's outside the `AttributeError()` call if you look closely at the parentheses.
Wait:
`raise AttributeError("{} object does not have {} attribute").format(obj, attr)`
This will raise `AttributeError` with the message `{} object does not have {} attribute`, and then it will try to call `.format()` on the *raised* exception or the exception object? No, `raise` is a statement.
Actually:
`raise AttributeError("{} object does not have {} attribute").format(obj, attr)`
is parsed as:
`raise (AttributeError("{} object does not have {} attribute")).format(obj, attr)`
But `AttributeError` is an exception, not a string. `AttributeError().format()` would fail.

Let me check the actual file content again carefully.

```python
                except AttributeError:
                    raise AttributeError("{} object does not have {} attribute").format(
                        obj, attr
                    )
```
Wait, I see it now in the `read_file` output:
```python
                except AttributeError:
                    raise AttributeError("{} object does not have {} attribute").format(
                        obj, attr
                    )
```
If this code is actually executed, it will raise `AttributeError` with the message `{} object does not have {} attribute` and then it will return a new `AttributeError` (or something) if `.format` worked on the exception. But `AttributeError` object does not have a `.format` method.
Wait, `AttributeError(...)` creates an exception object. Then `.format(...)` is called on that object.
That should raise another `AttributeError`: `'AttributeError' object has no attribute 'format'`.

Wait, let me check the `read_file` again.

```python
                except AttributeError:
                    raise AttributeError("{} object does not have {} attribute").format(
                        obj, attr
                    )
```
Yes, the parentheses for `AttributeError` close before `.format`.

But the task is to make `obj_or_str` more in line with `obj_or_id`.

One thing to notice about `obj_or_id`:
```python
    try:
        return int(parameter)
    except (ValueError, TypeError):
```
If `parameter` is already an `int`, it returns it.
If `parameter` is a `str` that can be converted to `int`, it returns it.

For `obj_or_str`, if `obj` is already a `str`, it should return it.

Let's rewrite `obj_or_str` to be cleaner and handle strings first.

```python
def obj_or_str(obj, attr, object_types):
    """
    Accepts either a string or an object. If it is a string, return it.
    If it is an object and the object is of correct type, return the
    object's attribute as a string. Otherwise, throw an exception.

    :param obj: str or object
    :param attr: name of the attribute to retrieve
    :param object_types: tuple containing the types of the object being passed in
    :rtype: str
    """
    if isinstance(obj, str):
        return obj
    
    for obj_type in object_types:
        if isinstance(obj, obj_type):
            try:
                return str(getattr(obj, attr))
            except AttributeError:
                raise AttributeError("{} object does not have {} attribute".format(
                    obj, attr
                ))

    obj_type_list = ",".join([obj_type.__name__ for obj_type in object_types])
    raise TypeError("Parameter {} must be of type {} or str.".format(obj, obj_type_list))
```

Wait, let's see the original `obj_or_str` again. It had a `try...except` at the beginning:
```python
    try:
        return str(getattr(obj, attr))
    except (AttributeError, TypeError):
        if not isinstance(attr, str):
            raise TypeError(
                "Atttibute parameter {} must be of type string".format(attr)
            )
```
The original code tried `getattr(obj, attr)` first. If `obj` is a `Feature` object, it works. If `obj` is a string, `getattr('some_str', 'name')` raises `AttributeError`.
Then it checks if `attr` is a string.
Then it checks if `obj` is one of `object_types`.

The problem statement says "Update `obj_or_str` to be more in line with `obj_or_id`".

`obj_or_id`'s structure is:
1. Try to cast to `int`.
2. If it fails, check for special cases.
3. Check if it's one of the `object_types`.
4. If it is, get the `.id` (and cast to `int`).
5. If nothing works, raise `TypeError`.

Applying this to `obj_or_str`:
1. Check if it's already a `str` (or can be cast to `str`, but everything can be cast to `str`).
2. Check if it's one of the `object_types`.
3. If it is, get the attribute `attr` (and cast to `str`).
4. If nothing works, raise `TypeError`.

So:
```python
def obj_or_str(obj, attr, object_types):
    if isinstance(obj, str):
        return obj
    
    for obj_type in object_types:
        if isinstance(obj, obj_type):
            try:
                return str(getattr(obj, attr))
            except AttributeError:
                raise AttributeError("{} object does not have {} attribute".format(
                    obj, attr
                ))
    
    obj_type_list = ",".join([obj_type.__name__ for obj_type in object_types])
    raise TypeError("Parameter {} must be of type {} or str.".format(obj, obj_type_list))
```

Wait, if I want to be EXTREMELY "in line" with `obj_or_id`, I should follow its pattern.
`obj_or_id` does:
```python
    try:
        return int(parameter)
    except (ValueError, TypeError):
```
For `obj_or_str`, `str(obj)` would always work for almost anything. So we can't just do `try: return str(obj)`.
We must check `isinstance(obj, str)`.

Let's see if there's any other reason for the `try...except` at the beginning of the original `obj_or_str`.
```python
    try:
        return str(getattr(obj, attr))
    except (AttributeError, TypeError):
```
This allows *any* object that has the attribute `attr` to be used, even if it's not in `object_types`.
Wait, `obj_or_id` does NOT do that. It strictly checks `object_types` if the `int()` cast fails.

So if we want `obj_or_str` to be like `obj_or_id`, we should probably stick to `object_types`.

Let's re-read `obj_or_id` again.
```python
def obj_or_id(parameter, param_name, object_types):
    ...
    try:
        return int(parameter)
    except (ValueError, TypeError):
        # Special case where 'self' is a valid ID of a User object
        if User in object_types and parameter == "self":
            return parameter

        for obj_type in object_types:
            if isinstance(parameter, obj_type):
                try:
                    return int(parameter.id)
                except Exception:
                    break
```

So the logic for `obj_or_str` should be:
1. If `obj` is `str`, return it.
2. (Optional: special cases)
3. If `obj` is one of `object_types`, return `str(getattr(obj, attr))`.
4. Raise `TypeError`.

Wait, if `obj` is already a string, it should be returned.

Let's refine the implementation.

```python
def obj_or_str(obj, attr, object_types):
    """
    Accepts either a string or an object. If it is a string, return it.
    If it is an object and the object is of correct type, return the
    corresponding attribute as a string. Otherwise, throw an exception.

    :param obj: str or object
    :param attr: name of the attribute to retrieve
    :param object_types: tuple containing the types of the object being passed in
    :rtype: str
    """
    if isinstance(obj, str):
        return obj

    for obj_type in object_types:
        if isinstance(obj, obj_type):
            try:
                return str(getattr(obj, attr))
            except AttributeError:
                raise AttributeError("{} object does not have {} attribute".format(
                    obj, attr
                ))

    obj_type_list = ",".join([obj_type.__name__ for obj_type in object_types])
    raise TypeError("Parameter {} must be of type {} or str.".format(obj, obj_type_list))
```

Wait, let me check the original error message of `obj_or_str`:
`raise TypeError("Parameter {} must be of type {}.\".format(obj, obj_type_list))`
(Note the typo in the original: `\"` at the end instead of `\"` at the beginning, and it uses `obj` as the first argument to format).

Let's look at `obj_or_id`'s error message:
`message = "Parameter {} must be of type {} or int.".format(param_name, obj_type_list)`
It uses `param_name` instead of the value of the parameter.
`obj_or_str` doesn't take a `param_name` argument. It takes `obj` and `attr`.

Maybe I should add `param_name` to `obj_or_str`? No, that would break callers.
Callers are:
`feature_name = obj_or_str(feature, "name", (Feature,))`

So `obj` is the parameter. I should probably use a generic "parameter" or just the value of `obj` in the error message if `param_name` is not available.

Let's check if any other function uses `obj_or_str` and what they pass.
I'll grep for `obj_or_str(`.

{
  "command": "grep -rn \"obj_or_str(\" ."
}

{
  "status": "ok",
  "stdout": "./canvasapi/user.py:515:        feature_name = obj_or_str(feature, \"name\", (Feature,))\n./canvasapi/account.py:1103:        feature_name = obj_or_str(feature, \"name\", (Feature,))\n./canvasapi/util.py:136:def obj_or_str(obj, attr, object_types):\n./canvasapi/course.py:1327:        feature_name = obj_or_str(feature, \"name\", (Feature,))\n./canvasapi/feature.py:71:        feature_name = obj_or_str(feature, \"name\", (Feature,))\n./canvasapi/feature.py:103:        feature_name = obj_or_str(feature, \"name\", (Feature,))\n./tests/test_util.py:433:    # obj_or_str()\n./tests/test_util.py:439:        user_name = obj_or_str(user, \"name\", (User,))\n./tests/test_util.py:450:            obj_or_str(user, \"display_name\", (User,))\n./tests/test_util.py:457:        user_name = obj_or_str(user, \"name\", (CourseNickname, User))\n./tests/test_util.py:467:            obj_or_str(user, user, (User,))\n./tests/test_util.py:471:            obj_or_str(\"user\", \"name\", (User,))\n",
  "stderr": "",
  "exit_code": 0
}

Let's check `tests/test_util.py` to see how it's tested.

{
  "end_line": 480,
  "filepath": "tests/test_util.py",
  "start_line": 430
}

{
  "status": "ok",
  "filepath": "tests/test_util.py",
  "content": "        with self.assertRaises(TypeError):\n            obj_or_id(\"self\", \"user_id\", (CourseNickname,))\n\n    # obj_or_str()\n    def test_obj_or_str_obj_attr(self, m):\n        register_uris({\"user\": [\"get_by_id\"]}, m)\n\n        user = self.canvas.get_user(1)\n\n        user_name = obj_or_str(user, \"name\", (User,))\n\n        self.assertIsInstance(user_name, str)\n        self.assertEqual(user_name, \"John Doe\")\n\n    def test_obj_or_str_obj_no_attr(self, m):\n        register_uris({\"user\": [\"get_by_id\"]}, m)\n\n        user = self.canvas.get_user(1)\n\n        with self.assertRaises(AttributeError):\n            obj_or_str(user, \"display_name\", (User,))\n\n    def test_obj_or_str_mult_obj(self, m):\n        register_uris({\"user\": [\"get_by_id\"]}, m)\n\n        user = self.canvas.get_user(1)\n\n        user_name = obj_or_str(user, \"name\", (CourseNickname, User))\n\n        self.assertIsInstance(user_name, str)\n\n    def test_obj_or_str_invalid_attr_parameter(self, m):\n        register_uris({\"user\": [\"get_by_id\"]}, m)\n\n        user = self.canvas.get_user(1)\n\n        with self.assertRaises(TypeError):\n            obj_or_str(user, user, (User,))\n\n    def test_obj_or_str_invalid_obj_type(self, m):\n        with self.assertRaises(TypeError):\n            obj_or_str(\"user\", \"name\", (User,))\n\n    # get_institution_url()\n    def test_get_institution_url(self, m):\n        correct_url = \"https://my.canvas.edu\"\n\n        # strip trailing slash\n        self.assertEqual(get_institution_url(\"https://my.canvas.edu/\"), correct_url)\n        # strip trailing slash but keep path\n        self.assertEqual(",
  "start_line": 430,
  "end_line": 480,
  "total_lines": 574,
  "is_truncated": false
}