{"id":42156458,"url":"https://github.com/choco-technologies/dmenv","last_synced_at":"2026-01-26T19:18:28.177Z","repository":{"id":322970290,"uuid":"1091619572","full_name":"choco-technologies/dmenv","owner":"choco-technologies","description":"DMOD Environment Variables","archived":false,"fork":false,"pushed_at":"2025-11-30T00:59:50.000Z","size":81,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2025-12-02T05:36:55.771Z","etag":null,"topics":["dmenv","dmod","getenv","setenv","staticlibrary"],"latest_commit_sha":null,"homepage":"","language":"C","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/choco-technologies.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-11-07T09:18:23.000Z","updated_at":"2025-11-30T00:59:54.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/choco-technologies/dmenv","commit_stats":null,"previous_names":["choco-technologies/dmenv"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/choco-technologies/dmenv","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/choco-technologies%2Fdmenv","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/choco-technologies%2Fdmenv/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/choco-technologies%2Fdmenv/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/choco-technologies%2Fdmenv/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/choco-technologies","download_url":"https://codeload.github.com/choco-technologies/dmenv/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/choco-technologies%2Fdmenv/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28785245,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-26T13:55:28.044Z","status":"ssl_error","status_checked_at":"2026-01-26T13:55:26.068Z","response_time":59,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"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":["dmenv","dmod","getenv","setenv","staticlibrary"],"created_at":"2026-01-26T19:18:25.112Z","updated_at":"2026-01-26T19:18:28.165Z","avatar_url":"https://github.com/choco-technologies.png","language":"C","funding_links":[],"categories":[],"sub_categories":[],"readme":"# dmenv - DMOD Environment Variables Manager\n\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)\n\nA lightweight environment variables manager designed specifically for the **DMOD (Dynamic Modules)** framework. dmenv provides a simple and efficient way to manage environment variables in embedded systems with limited resources.\n\n## Table of Contents\n\n- [Overview](#overview)\n- [What is DMOD?](#what-is-dmod)\n- [What is dmenv?](#what-is-dmenv)\n- [Features](#features)\n- [Building](#building)\n- [Testing](#testing)\n- [Usage](#usage)\n- [API Reference](#api-reference)\n- [Contributing](#contributing)\n- [License](#license)\n\n## Overview\n\ndmenv is a custom environment variables manager that integrates seamlessly with the DMOD dynamic module system. It provides a context-based solution for storing and retrieving configuration parameters, making it ideal for embedded systems where flexibility and modularity are important. With support for context inheritance, multiple isolated environments can be managed efficiently.\n\n## What is DMOD?\n\n**DMOD (Dynamic Modules)** is a library that enables dynamic loading and unloading of modules in embedded systems at runtime. It allows you to:\n\n- **Dynamically load modules**: Load functionality from `.dmf` files without recompiling\n- **Manage dependencies**: Automatically handle module dependencies\n- **Inter-module communication**: Modules can communicate via a common API\n- **Resource management**: Efficiently manage system resources\n- **Safe updates**: Update individual modules without affecting the entire system\n\nDMOD provides a modular architecture that makes embedded systems more flexible, maintainable, and easier to extend. For more information, visit the [DMOD repository](https://github.com/choco-technologies/dmod).\n\n## What is dmenv?\n\n**dmenv** is an environment variables manager specifically designed to work with DMOD. It provides:\n\n- **Simple key-value storage**: Store configuration parameters as name-value pairs\n- **Context-based management**: Create multiple isolated environment contexts\n- **Context inheritance**: Child contexts can inherit variables from parent contexts\n- **Context stack**: Push and pop contexts for temporary context switching\n- **Thread-safe operations**: Uses DMOD's critical section mechanisms\n- **Prefix-based search**: Find all variables matching a specific prefix\n- **Efficient lookup**: Fast variable retrieval using linked list structure\n- **Integer support**: Set and get variables as unsigned integers (hex or decimal)\n- **Module integration**: Seamless integration with DMOD logging and error handling\n\ndmenv is ideal for storing application configuration, runtime parameters, and inter-module communication data in embedded DMOD-based systems.\n\n## Features\n\n- ✅ **Context-based management**: Create multiple isolated environment contexts\n- ✅ **Context inheritance**: Child contexts can inherit variables from parent contexts\n- ✅ **Context stack**: Push and pop contexts for temporary context switching\n- ✅ **Root context**: Set a global root context as the base fallback\n- ✅ **Key-value storage**: Store and retrieve environment variables by name\n- ✅ **Variable update**: Update existing variables without creating duplicates\n- ✅ **Variable removal**: Remove individual variables or clear all at once\n- ✅ **Prefix search**: Find all variables matching a given prefix\n- ✅ **Variable counting**: Track the number of stored variables\n- ✅ **Integer support**: Set and get variables as unsigned integers (hex or decimal)\n- ✅ **Dynamic allocation**: Uses DMOD's memory management system\n- ✅ **Thread-safe**: Uses DMOD critical sections for synchronization\n- ✅ **Comprehensive logging**: Integration with DMOD logging system\n- ✅ **Zero external dependencies**: Only requires DMOD framework\n\n## Building\n\n### Prerequisites\n\n- **CMake**: Version 3.10 or higher\n- **C Compiler**: GCC or compatible\n- **Make**: For Makefile-based builds (optional)\n\n### Using CMake\n\n```bash\n# Clone the repository\ngit clone https://github.com/choco-technologies/dmenv.git\ncd dmenv\n\n# Create build directory\nmkdir build\ncd build\n\n# Configure\ncmake ..\n\n# Build\nmake\n\n# Run tests\nctest --verbose\n```\n\n### Build Options\n\nYou can customize the build with these CMake options:\n\n```bash\n# Enable tests\ncmake -DDMENV_BUILD_TESTS=ON ..\n\n# Disable DMOD API implementation\ncmake -DDMENV_DONT_IMPLEMENT_DMOD_API=ON ..\n\n# Change DMOD mode\ncmake -DDMOD_MODE=DMOD_EMBEDDED ..\n```\n\n### Using Makefile\n\ndmenv also supports traditional Makefile builds:\n\n```bash\n# Build the library\nmake\n\n# The library will be created as libdmenv.a\n```\n\n## Testing\n\ndmenv includes comprehensive test suites:\n\n### Test Suites\n\n1. **test_minimal**: Minimal smoke tests\n   - Context creation and destruction\n   - Basic set/get operations\n   - Count and remove operations\n   - Integer operations\n\n2. **test_simple**: Simple functional tests\n   - Set and get variables\n   - Remove variables\n   - Clear all variables\n   - Find variables by prefix\n   - Integer operations\n   - Context inheritance\n\n3. **test_dmenv_unit**: Comprehensive unit tests using Unity framework\n   - Context creation and validation\n   - Set/get operations\n   - Update existing variables\n   - Remove operations\n   - Clear all variables\n   - Count operations\n   - Find operations with prefixes\n   - Integer operations (seti/geti)\n   - Context inheritance\n   - Context override behavior\n   - Root context management\n   - Context stack push/pop operations\n   - Multiple variable stress tests\n\n### Running Tests\n\n```bash\n# Run all tests\ncd build\nctest\n\n# Run with verbose output\nctest --verbose\n\n# Run specific test\n./tests/test_minimal\n./tests/test_simple\n./tests/test_dmenv_unit\n```\n\n## Usage\n\n### Basic Usage\n\n```c\n#include \"dmenv.h\"\n#include \u003cstring.h\u003e\n\nint main(void) {\n    // 1. Create an environment context\n    dmenv_ctx_t ctx = dmenv_create(NULL);\n    if (ctx == NULL) {\n        // Handle creation failure\n        return -1;\n    }\n    \n    // 2. Set environment variables\n    dmenv_set(ctx, \"APP_NAME\", \"MyApplication\");\n    dmenv_set(ctx, \"APP_VERSION\", \"1.0.0\");\n    dmenv_set(ctx, \"DEBUG_MODE\", \"true\");\n    \n    // 3. Get environment variables\n    const char* app_name = dmenv_get(ctx, \"APP_NAME\");\n    if (app_name != NULL) {\n        printf(\"Application: %s\\n\", app_name);\n    }\n    \n    // 4. Clean up\n    dmenv_destroy(ctx);\n    \n    return 0;\n}\n```\n\n### Update Variables\n\n```c\n#include \"dmenv.h\"\n\nvoid config_example(void) {\n    dmenv_ctx_t ctx = dmenv_create(NULL);\n    \n    // Set initial value\n    dmenv_set(ctx, \"LOG_LEVEL\", \"INFO\");\n    \n    // Update the value (no duplicate created)\n    dmenv_set(ctx, \"LOG_LEVEL\", \"DEBUG\");\n    \n    // Get updated value\n    const char* level = dmenv_get(ctx, \"LOG_LEVEL\");\n    // level now contains \"DEBUG\"\n    \n    dmenv_destroy(ctx);\n}\n```\n\n### Remove Variables\n\n```c\n#include \"dmenv.h\"\n\nvoid cleanup_example(void) {\n    dmenv_ctx_t ctx = dmenv_create(NULL);\n    \n    // Set a temporary variable\n    dmenv_set(ctx, \"TEMP_DATA\", \"temporary_value\");\n    \n    // Remove it when done\n    bool removed = dmenv_remove(ctx, \"TEMP_DATA\");\n    if (removed) {\n        printf(\"Temporary data removed\\n\");\n    }\n    \n    // Variable no longer exists\n    const char* value = dmenv_get(ctx, \"TEMP_DATA\");\n    // value is NULL\n    \n    dmenv_destroy(ctx);\n}\n```\n\n### Find Variables by Prefix\n\n```c\n#include \"dmenv.h\"\n\nvoid print_var(const char* name, const char* value, void* user_data) {\n    printf(\"%s = %s\\n\", name, value);\n}\n\nvoid find_example(void) {\n    dmenv_ctx_t ctx = dmenv_create(NULL);\n    \n    // Set related variables with common prefix\n    dmenv_set(ctx, \"DB_HOST\", \"localhost\");\n    dmenv_set(ctx, \"DB_PORT\", \"5432\");\n    dmenv_set(ctx, \"DB_NAME\", \"mydb\");\n    dmenv_set(ctx, \"APP_NAME\", \"myapp\");\n    \n    // Find all database-related variables\n    printf(\"Database configuration:\\n\");\n    size_t found = dmenv_find(ctx, \"DB_\", print_var, NULL);\n    printf(\"Found %zu database variables\\n\", found);\n    \n    dmenv_destroy(ctx);\n}\n```\n\n### Clear All Variables\n\n```c\n#include \"dmenv.h\"\n\nvoid reset_example(void) {\n    dmenv_ctx_t ctx = dmenv_create(NULL);\n    \n    // Clear all environment variables\n    dmenv_clear(ctx);\n    \n    // Verify count is 0\n    size_t count = dmenv_count(ctx);\n    printf(\"Variables remaining: %zu\\n\", count);  // Prints: 0\n    \n    dmenv_destroy(ctx);\n}\n```\n\n### Context Stack Example\n\n```c\n#include \"dmenv.h\"\n\nvoid context_stack_example(void) {\n    // Create root and temporary contexts\n    dmenv_ctx_t root = dmenv_create(NULL);\n    dmenv_ctx_t temp = dmenv_create(NULL);\n    \n    // Set root context as the base\n    dmenv_set_root_context(root);\n    dmenv_set(root, \"MODE\", \"production\");\n    \n    // Get current context (returns root)\n    dmenv_ctx_t current = dmenv_get_current_context();\n    printf(\"Mode: %s\\n\", dmenv_get(current, \"MODE\"));  // Prints: production\n    \n    // Push temporary context for testing\n    dmenv_push_context(temp);\n    dmenv_set(temp, \"MODE\", \"testing\");\n    \n    // Get current context (returns temp)\n    current = dmenv_get_current_context();\n    printf(\"Mode: %s\\n\", dmenv_get(current, \"MODE\"));  // Prints: testing\n    \n    // Pop temporary context\n    dmenv_pop_context();\n    \n    // Get current context (returns root again)\n    current = dmenv_get_current_context();\n    printf(\"Mode: %s\\n\", dmenv_get(current, \"MODE\"));  // Prints: production\n    \n    dmenv_destroy(temp);\n    dmenv_destroy(root);\n}\n```\n\n### Integration Example\n\n```c\n#include \"dmenv.h\"\n#include \"dmod.h\"\n#include \u003cstdio.h\u003e\n\nvoid load_configuration(dmenv_ctx_t ctx) {\n    // Load configuration from persistent storage or hardcode\n    dmenv_set(ctx, \"SYSTEM_NAME\", \"EmbeddedDevice\");\n    dmenv_set(ctx, \"FIRMWARE_VERSION\", \"2.1.3\");\n    dmenv_set(ctx, \"NETWORK_ENABLED\", \"true\");\n    dmenv_set(ctx, \"NETWORK_IP\", \"192.168.1.100\");\n    dmenv_set(ctx, \"NETWORK_PORT\", \"8080\");\n    dmenv_set(ctx, \"SENSOR_SAMPLE_RATE\", \"1000\");\n    dmenv_set(ctx, \"SENSOR_THRESHOLD\", \"75.5\");\n}\n\nvoid print_all_network_settings(const char* name, const char* value, void* user_data) {\n    printf(\"  %s = %s\\n\", name, value);\n}\n\nint main(void) {\n    printf(\"=== Embedded System Configuration ===\\n\\n\");\n    \n    // Create environment context\n    dmenv_ctx_t ctx = dmenv_create(NULL);\n    if (ctx == NULL) {\n        printf(\"ERROR: Failed to create environment context\\n\");\n        return -1;\n    }\n    \n    // Load configuration\n    load_configuration(ctx);\n    \n    printf(\"Configuration loaded: %zu variables\\n\\n\", dmenv_count(ctx));\n    \n    // Display system info\n    printf(\"System: %s\\n\", dmenv_get(ctx, \"SYSTEM_NAME\"));\n    printf(\"Firmware: %s\\n\\n\", dmenv_get(ctx, \"FIRMWARE_VERSION\"));\n    \n    // Display network settings\n    printf(\"Network Configuration:\\n\");\n    dmenv_find(ctx, \"NETWORK_\", print_all_network_settings, NULL);\n    \n    // Display sensor settings\n    printf(\"\\nSensor Configuration:\\n\");\n    dmenv_find(ctx, \"SENSOR_\", print_all_network_settings, NULL);\n    \n    // Clean up\n    dmenv_destroy(ctx);\n    \n    return 0;\n}\n```\n\n## API Reference\n\n### Context Management\n\n#### `dmenv_create`\n\n```c\ndmenv_ctx_t dmenv_create(dmenv_ctx_t parent);\n```\n\nCreate a new environment variables context.\n\n- **Parameters:**\n  - `parent`: Optional parent context for variable inheritance. If a variable is not found in the current context, it will be searched in the parent context. Pass NULL for no inheritance.\n- **Returns:** Pointer to the created context, or NULL on failure\n- **Thread-safe:** Yes\n\n#### `dmenv_destroy`\n\n```c\nvoid dmenv_destroy(dmenv_ctx_t ctx);\n```\n\nDestroy an environment variables context.\n\n- **Parameters:**\n  - `ctx`: Context to destroy\n- **Thread-safe:** Yes\n\n#### `dmenv_is_valid`\n\n```c\nbool dmenv_is_valid(dmenv_ctx_t ctx);\n```\n\nCheck if a context is valid.\n\n- **Parameters:**\n  - `ctx`: Context to check\n- **Returns:** `true` if valid, `false` otherwise\n- **Thread-safe:** Yes\n\n#### `dmenv_set_root_context`\n\n```c\nvoid dmenv_set_root_context(dmenv_ctx_t ctx);\n```\n\nSet the root context. The root context serves as the base context when no other contexts have been pushed onto the context stack.\n\n- **Parameters:**\n  - `ctx`: Context to set as root context\n- **Thread-safe:** Yes\n\n#### `dmenv_get_root_context`\n\n```c\ndmenv_ctx_t dmenv_get_root_context(void);\n```\n\nGet the root context.\n\n- **Returns:** Pointer to the root context, or NULL if not set\n- **Thread-safe:** Yes\n\n#### `dmenv_push_context`\n\n```c\nbool dmenv_push_context(dmenv_ctx_t ctx);\n```\n\nPush a context onto the context stack. The pushed context becomes the current context.\n\n- **Parameters:**\n  - `ctx`: Context to push onto the stack\n- **Returns:** `true` if the context was pushed successfully, `false` otherwise (e.g., stack overflow or invalid context)\n- **Thread-safe:** Yes\n\n#### `dmenv_pop_context`\n\n```c\ndmenv_ctx_t dmenv_pop_context(void);\n```\n\nPop the current context from the context stack. After popping, the previous context on the stack becomes the current context. If the stack is empty, the root context becomes the current context.\n\n- **Returns:** Pointer to the popped context, or NULL if the stack was empty\n- **Thread-safe:** Yes\n\n#### `dmenv_get_current_context`\n\n```c\ndmenv_ctx_t dmenv_get_current_context(void);\n```\n\nGet the current context. Returns the top context from the stack if any contexts have been pushed, otherwise returns the root context.\n\n- **Returns:** Pointer to the current context, or NULL if no context is set\n- **Thread-safe:** Yes\n\n### Variable Operations\n\n#### `dmenv_set`\n\n```c\nbool dmenv_set(dmenv_ctx_t ctx, const char* name, const char* value);\n```\n\nSet an environment variable. If the variable already exists, its value is updated.\n\n- **Parameters:**\n  - `ctx`: Context to set the variable in\n  - `name`: Name of the environment variable\n  - `value`: Value to set\n- **Returns:** `true` if the variable was set successfully, `false` otherwise\n- **Thread-safe:** Yes\n\n#### `dmenv_get`\n\n```c\nconst char* dmenv_get(dmenv_ctx_t ctx, const char* name);\n```\n\nGet an environment variable value. If the variable is not found in the context and the context has a parent, the parent will be searched recursively.\n\n- **Parameters:**\n  - `ctx`: Context to get the variable from\n  - `name`: Name of the environment variable\n- **Returns:** Pointer to the value string, or NULL if not found\n- **Thread-safe:** Yes\n- **Note:** The returned pointer is valid until the variable is removed or modified\n\n#### `dmenv_seti`\n\n```c\nbool dmenv_seti(dmenv_ctx_t ctx, const char* name, uint32_t value);\n```\n\nSet an environment variable (unsigned integer value in hex). The value is stored internally as a hexadecimal string (e.g., \"0x2000\").\n\n- **Parameters:**\n  - `ctx`: Context to set the variable in\n  - `name`: Name of the environment variable\n  - `value`: Unsigned integer value to set\n- **Returns:** `true` if the variable was set successfully, `false` otherwise\n- **Thread-safe:** Yes\n\n#### `dmenv_geti`\n\n```c\nbool dmenv_geti(dmenv_ctx_t ctx, const char* name, uint32_t* out_value);\n```\n\nGet an environment variable value (unsigned integer). Parses the value as a hexadecimal or decimal number. If the variable is not found in the context and the context has a parent, the parent will be searched.\n\n- **Parameters:**\n  - `ctx`: Context to get the variable from\n  - `name`: Name of the environment variable\n  - `out_value`: Pointer to store the parsed value\n- **Returns:** `true` if the variable was found and parsed successfully, `false` otherwise\n- **Thread-safe:** Yes\n\n#### `dmenv_remove`\n\n```c\nbool dmenv_remove(dmenv_ctx_t ctx, const char* name);\n```\n\nRemove an environment variable. Only removes from the current context, not from parent contexts.\n\n- **Parameters:**\n  - `ctx`: Context to remove the variable from\n  - `name`: Name of the environment variable to remove\n- **Returns:** `true` if the variable was removed successfully, `false` if not found\n- **Thread-safe:** Yes\n\n#### `dmenv_clear`\n\n```c\nbool dmenv_clear(dmenv_ctx_t ctx);\n```\n\nClear all environment variables in a context. Only clears variables in the current context, not in parent contexts.\n\n- **Parameters:**\n  - `ctx`: Context to clear\n- **Returns:** `true` if all variables were cleared successfully, `false` otherwise\n- **Thread-safe:** Yes\n\n### Query Operations\n\n#### `dmenv_find`\n\n```c\nsize_t dmenv_find(dmenv_ctx_t ctx, const char* prefix, \n                  void (*callback)(const char* name, const char* value, void* user_data), \n                  void* user_data);\n```\n\nFind environment variables matching a prefix. Only searches in the current context, not in parent contexts.\n\n- **Parameters:**\n  - `ctx`: Context to search in\n  - `prefix`: Prefix to match against variable names\n  - `callback`: Callback function to call for each matching variable\n  - `user_data`: User data to pass to the callback\n- **Returns:** Number of matching variables found\n- **Thread-safe:** Yes\n\n#### `dmenv_count`\n\n```c\nsize_t dmenv_count(dmenv_ctx_t ctx);\n```\n\nGet the number of environment variables in a context. Only counts variables in the current context, not in parent contexts.\n\n- **Parameters:**\n  - `ctx`: Context to count variables in\n- **Returns:** Number of environment variables\n- **Thread-safe:** Yes\n\n## Contributing\n\nContributions are welcome! Please feel free to submit issues, fork the repository, and create pull requests.\n\n### Development Setup\n\n1. Fork the repository\n2. Clone your fork: `git clone https://github.com/YOUR_USERNAME/dmenv.git`\n3. Create a feature branch: `git checkout -b feature/my-new-feature`\n4. Make your changes and add tests\n5. Run tests: `cd build \u0026\u0026 ctest`\n6. Commit your changes: `git commit -am 'Add some feature'`\n7. Push to the branch: `git push origin feature/my-new-feature`\n8. Submit a pull request\n\n## License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\n\n## Related Projects\n\n- [DMOD](https://github.com/choco-technologies/dmod) - Dynamic Module Loading Framework\n- [dmheap](https://github.com/choco-technologies/dmheap) - DMOD Heap Memory Manager\n- [dmlog](https://github.com/choco-technologies/dmlog) - DMOD Logging System\n\n---\n\n**For more information and support, please visit the [dmenv repository](https://github.com/choco-technologies/dmenv) or contact the Choco-Technologies team.**\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fchoco-technologies%2Fdmenv","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fchoco-technologies%2Fdmenv","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fchoco-technologies%2Fdmenv/lists"}