{"id":18567136,"url":"https://github.com/vahidzee/dypy","last_synced_at":"2026-03-17T20:06:49.249Z","repository":{"id":63992233,"uuid":"571829441","full_name":"vahidzee/dypy","owner":"vahidzee","description":"Toolkit for Dynamic Python code manipulations","archived":false,"fork":false,"pushed_at":"2023-03-22T23:41:32.000Z","size":294,"stargazers_count":11,"open_issues_count":6,"forks_count":1,"subscribers_count":2,"default_branch":"main","last_synced_at":"2024-04-25T03:02:16.075Z","etag":null,"topics":["dynamic-code-execution","dynamic-objects","functional-programming","lazy-evaluation"],"latest_commit_sha":null,"homepage":"","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/vahidzee.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":"CITATION.cff","codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2022-11-29T01:06:23.000Z","updated_at":"2023-07-28T19:16:58.000Z","dependencies_parsed_at":"2024-11-06T22:31:18.848Z","dependency_job_id":"e80b10ab-f7a7-45c3-8af5-2bfc2f801777","html_url":"https://github.com/vahidzee/dypy","commit_stats":{"total_commits":16,"total_committers":3,"mean_commits":5.333333333333333,"dds":0.5625,"last_synced_commit":"d91270dbb567fe68cf2b2f1fb0c1c530841c71de"},"previous_names":["vahidzee/dycode"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vahidzee%2Fdypy","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vahidzee%2Fdypy/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vahidzee%2Fdypy/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vahidzee%2Fdypy/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/vahidzee","download_url":"https://codeload.github.com/vahidzee/dypy/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248163258,"owners_count":21057894,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["dynamic-code-execution","dynamic-objects","functional-programming","lazy-evaluation"],"created_at":"2024-11-06T22:25:33.091Z","updated_at":"2026-03-17T20:06:49.222Z","avatar_url":"https://github.com/vahidzee.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Dynamic Python (DyPy): a toolset for dynamic python code manipulations\n\nHave you ever found yourself coding up boilerplates to handle different scenarios? It's most likely that you have thought about using python's `eval` or `exec` in order to decouple some part of your code to be specified and evaluated later on at run-time. But, you have probably also come accross people who discourage you from using `eval`/`exec`. This is because programs with `eval`/`exec` are considered vulnarable and can be used to execute malicious code.\n\nWhile this is true in general, but in many cases, you do not care about security concerns, and your highest priority is implementing a quick solution to a general problem which could be solved by using `eval` or `exec`. This is where dypy comes in. It allows you to use `eval` and `exec` effectively by providing utilities to dynamically compile code, lookup variables and lazily evaluate them.\n\n**Table of Contents**\n- [Dynamic Python (DyPy): a toolset for dynamic python code manipulations](#dynamic-python-dypy-a-toolset-for-dynamic-python-code-manipulations)\n  - [Installation](#installation)\n  - [Usage](#usage)\n    - [Dynamic Evaluation](#dynamic-evaluation)\n      - [Variable Lookup](#variable-lookup)\n      - [Dynamic Function Evaluation](#dynamic-function-evaluation)\n    - [Variable Assignment](#variable-assignment)\n  - [License](#license)\n  - [Citation](#citation)\n\n## Installation\n\n```bash\npip install dypy\n```\n\n## Usage\n\n### Dynamic Evaluation\n\nYou can use `dypy.eval` to combine the functionality of `dypy.eval_function` (see [here](#dynamic-function-evaluation)) and `dypy.get_value` (see [here](#variable-lookup)). You can do as follows:\n\n```python\nimport dypy\n\ndypy.eval(\"math.cos\") # \u003cfunction \u003clambda\u003e at MEM_ADDRESS\u003e (math is imported through get_value)\ndypy.eval(\"math.cos\", dynamic_args=True)(2, verbose=True) # 3, verbose is ignored (and math is imported through get_value)\ndypy.eval(\"def my_function(x): return x + 1\", function_of_interest=\"my_function\") # \u003cfunction my_function at MEM_ADDRESS\u003e\ndypy.eval(\"def my_function(x): return x + y\", function_of_interest=\"my_function\", context={\"y\": 2})(2) # 4\n```\n\n\n#### Variable Lookup\n\nYou can use `dypy.get_value` to lookup a variable as a string and then evaluate it. This is useful when you want to use a variable that is not defined in the current scope. You can do as follows:\n\n```python\nfrom dypy import get_value\n\nget_value(\"math.pi\") # 3.141592653589793\nget_value(\"math.cos(0)\") # won't evaluate, this is not a variable but a call to a variable\nget_value(\"math.cos\")(0) # 1.0\n\nimport math\nget_value(\"cos\", context=math) # math.cos\n\nget_value(\"something_that_does_not_exist\") # raises NameError\nget_value(\"something_that_does_not_exist\", strict=False) # None\n```\n\n`get_value` supports looking up variables in a module or package in your current working directory as well (as opposed to python's `import` which only supports looking up variables in the python standard library and installed packages). This is useful when you want to create a script that can be run from anywhere and still be able to access variables in the current working directory. \n\nFor example, imagine you create your own python package with a runnable script that sorts files in a directory. You can use `get_value` to lookup a `config.sort` function in the current working directory. This way, you can create a `config.py` file in the current working directory and define your own sorting function. Or use a default sorting function if the `config.py` file does not exist. \n\nYour code would look like this:\n\n```python\nfrom dypy import get_value\n\ndef sort_files():\n    sort_function = get_value(\"config.sort\", strict=False) or default_sort\n    # do something with sort\n```\n\nAlthough this example is somewhat contrived, such a use case is very common in data science and machine learning. Imagine writing a package for training a Deep Learning model. You can use `get_value` to lookup custom Dataset classes and model implementations and this way, people can use your package without the need to modifying your code, because they can simply inject their own implementations in places where you have used `get_value`.\n\nAnother potential use case is defining Neural Network layers. You can use `get_value` to lookup custom layers and use them in your model. Such as:\n\n```python\nfrom dypy import get_value\nimport torch\n\nclass MyLinearBlock(torch.nn.Module):\n    def __init__(self, in_features, out_features, activation=\"torch.nn.ReLU\"):\n        super().__init__()\n        self.linear = torch.nn.Linear(in_features, out_features)\n        self.activation = get_value(activation, strict=False) \n\n    def forward(self, x):\n        x = self.linear(x)\n        x = self.activation(x) if self.activation else x\n        return x\n```\n\nThis way, you can change the activation function by simply changing the `activation` argument. For example, you can use `torch.nn.Sigmoid` or `torch.nn.Tanh` or even a custom activation function that you have defined in the current working directory or use one from a 3rd party package.\n\n#### Dynamic Function Evaluation\n\nWhat if you want to generate python programs dynamically? Meaning that you have a string that contains python code and you want to inject it into your program.  You can use `dypy.eval_function` to evaluate a piece of code and retrieve a function. You can do as follows:\n\n```python\nfrom dypy import eval_function\n\neval_function(\"lambda x: x + 1\") # \u003cfunction \u003clambda\u003e at MEM_ADDRESS\u003e\n\neval_function(\"def my_function(x): return x + 1\") # wont work, this is not a function, \n# but a code block and you need to mention your function_of_interest in that code block\n\neval_function(\"def my_function(x): return x + 1\", function_of_interest=\"my_function\") # \u003cfunction my_function at MEM_ADDRESS\u003e\n```\n\n`eval_function` accepts three types of function descriptors:\n\n1. A lambda function, e.g. `lambda x: x + 1`, or a code which evaluates to a callable object, `math.cos` (in this case, the values being looked up should be present in the evaluation context, more on this later).\n2. A code block, which can contain multiple lines and functions, in which case you need to specify the name of the function of interest using the `function_of_interest` argument. `eval_function` will evaluate the code block and retrieve your function of interest.\n3. A dictionary of \"code\", [\"context\", \"function_of_interest\"] pairs. Useful when you are using `eval_function` on top of a configuration file, in which case you can specify the code and the context for each function of interest.\n\nWhen evaluating a function descriptor, you can specify a context in which the code will be evaluated. This is useful when you want to use variables that are not defined in the current scope. `dypy` has a context registry that you can use as a global context for all your function evaluations.\n\n```python\nfrom dypy import eval_function, register_context\nimport math\n\nregister_context(math, \"math\") # register math package as a context\n# you can also use register(math), which will use the name of the package as the context name\n\neval_function(\"math.cos\") # \u003cfunction \u003clambda\u003e at MEM_ADDRESS\u003e (math is looked up through the context registry)\n```\n\nYou can also specify a context for each function evaluation using the `context` argument. The context is a dictionary of variable names and their values. You can do as follows:\n\n```python\neval_function(\"def my_function(x): return x + y\", function_of_interest=\"my_function\", context={\"y\": 1})(2) # 3\n```\n\nYou can also optionally set `dynamic_args=True`, when evaluating a function. This will create a function that intelligently evaluates its arguments, by wrapping it using `dypy.dynamic_args_wrapper`. Functions wrapped by `dypy.dynamic_args_wrapper` preprocess arguments passed to them, and ignore arguments that are not defined in the function signature. For instance:\n\n```python\neval_function(\"lambda x: x + 1\", dynamic_args=True)(2, verbose=True) # 3, verbose is ignored\n```\n\n### Variable Assignment\n\nThere are times when you want to assign a variable in a dynamic manner. Meaning that you want to change a variable's value that is not necessarily defined in the current scope. You can use `dypy.set_value` to do so.  You can do as follows:\n\n```python\nfrom dypy import set_value\n\nset_value(\"some_package.my_function\", lambda x: x + 1)\n\n# changing the value of pi in math package\nset_value(\"math.pi\", 3.14) \n\n# now if you import math, math.pi will be 3.14\nimport math\nmath.pi # 3.14\n```\n\n## License\n\ndypy is licensed under the MIT License. See [LICENSE](LICENSE) for the full license text.\n\n## Citation\n\nIf you use dypy in your research, please cite this repository as described in [CITATION.cff](CITATION.cff).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvahidzee%2Fdypy","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fvahidzee%2Fdypy","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvahidzee%2Fdypy/lists"}