semvec/pypi-packages huggingface dataset:
dependMLOps 0.0.1
Manage MLOps Dependencies and More...
Requires Python: >=3.9


```markdown
# Depend En Moi (Depend on Me) - Your ML and LLMOps Configuration Friend 👀


## 🚀 Quick Start to MLOps Automation

Depend En Moi streamlines your machine learning and LLM lifecycle management operation tools. It works by automating dependency management and environment setup. So you can focus on building and deploying your ML models faster and more efficiently. 🛠️

### Current Status
5th November 2023: **Early Development** 👼

### What It Does 🧐
Right now - not that much, it's brand new and the Nullzero's first module. Scary! 

Depend En Moi is a tool tailored for machine learning projects, with a special focus on MLOps tools such as Langchain, OpenAI (openai), Weights and Biases (wandb), and MLFlow (mflow), Humanloop (humanloop.com) -- Always adding more. 

Here's what it can do for you:

- 🔍 Automatically searches and installs dependencies for your selected libraries, or defaults if no custom list is provided.
- 🔐 Safely stores your API keys in a local `.env` file for easy access and security.
- 🚫 Ensures `.env` is added to your `.gitignore` to keep secrets out of version control.
- 🐳 Adds `.env` to your `.dockerfile` if one exists in your project.
- ✅ Handles login and other necessary preliminary steps to get you up and running.

Depend-en-moi is designed to get your application ready for a quick, streamlined login, and config in LangChain, WandB, HumanLoop, MLFlow, and more...

### Always Evolving 👷

This tool is constantly being improved to support the latest in MLOps best practices and libraries. Stay tuned for updates!

### Dependencies 📦

Here are the dependencies that Depend En Moi works with out of the box:

```plaintext
cachetools==5.3.2
GitPython==3.1.0
packaging==23.2
python-dotenv==1.0.0
pipdeptree==2.13.0
tree==0.2.4
langchain==0.0.330
openai==0.28.1
wandb==0.15.12
```

### Getting Started 🌟

To get started with Depend En Moi, simply clone this repository and run the main installation script:

```bash
git clone https://github.com/nullzero-live/depend-en-moi
cd depend-en-moi
python setup.py install
```

### Contributing 🤝

Interested in contributing? We love pull requests and issues from fellow MLOps enthusiasts. Fork away and submit your PR as necessary.

### License ⚖️

Depend En Moi is open-source software [licensed as MIT](LICENSE).

---

Made with 💖 and a lot of ☕ by [Nullzero](<https://github.com/nullzero-live/>).
```

---

## Aha-To-Do List

### ToDo:
- [ ] **Complete argparser for intuitive use**
- [ ] **Add a "--c" flag to arg_parser to add custom libraries**
- [ ] **Abstract out the library types for incorporation of any library**
- [ ] **Include MLFlow and Humanloop config**
- [ ] **Parse out the syntax from each**
- [ ] **Option to dump dependencies or next steps into an external file**

### Done ✅
- [x] **.Devcontainer**
- [x] **_constants**
- [x] **utils**
- [x] **main**
- [x] **planned structure**

### And dennnnn......
- [ ] ❌ **Very little (help a fellow out!)**

🤗🤗🤗🤗🤗🤗🤗🤗🤗🤗
evpsim 0.1.0
Python ElastoViscoPlastic mechanical behavior simulator

# ElastoViscoPlastic material SIMulator

## Description

The evpsim module simulates elasto-visco-plastic mechanical behavior for a given loading path (strain/stress/mixed).

Simulation is performed at the scale of a single material point. It would be conceivable to couple the evpsim module with a finite element code for structural calculations, but this would require some work to reorganize the code, particularly in terms of memory management. What's more, it would still be prohibitively expensive in terms of calculation costs compared with a dedicated implementation.

## Installation

### From sources

```bash
git clone https://github.com/basileMarchand/evpsim.git
cd evpsim
pip install .
```

Or even simplier

```bash
pip install git+https://github.com/basileMarchand/evpsim.git
```

### From PyPi

Coming soon

## Documentation

Coming soon
maplewood 0.3.0
A package for logging in plaintext
Requires Python: >=3.7

# Maplewood

maplewood is a Python Library for creating logfiles in Plain Text(.txt) Format

## Compatibility

maplewood has been tested to work on Windows, but should work on Linux and MacOS as well

## Installing

maplewood can be installed using pip or any PyPI package managers
```sh
pip install maplewood
``` 

## Usage

```python
# import the chainsaw module 
# containing the 'Chainsaw' class
from maplewood import chainsaw as cs

# creates a log.txt file in ./logs/
example_log = cs.Chainsaw()

# To log an event, we open the file first
example_log.open()

# To write to the log file
example_log.write(success=True, message="Example Task Executed")
# OR
# if we define a default success or failure message
example_log.update(success="Example success",
                   failure="Example Failure",
                   module="example")
example.log(False) # writes default fail state
example.log(True)  # writes default pass state

# we can close the file if needed
example_log.close()
# and reopen
example_log.open()

# to check if log file is open
example_log.is_open() # -> bool

# remember to close the file
example_log.close()
```
cloud-ranges 0.0.4
Discover if IP belongs cloud providers ranges

# cloud-ranges

Discover if IP belongs to cloud providers.

## Example

Here there are some usage examples:

```
$ echo 20.236.44.162 | cloud-ranges
20.236.44.162 azure westus2 20.236.0.0/18
```

```
$ echo 20.236.44.162 | cloud-ranges -j
{"cloud": "azure", "services": [], "region": "westus2", "network": "20.236.0.0/18", "target": "20.236.44.162"}
```

## Supported Cloud Providers

- AWS
- GCP
- Azure
- IBM
- DigitalOcean
- IBM Cloud


## Installation

```
pip install cloud-ranges
```
Imputation-Assisted-Randomization-Tests 0.1.0
Causal-I-ART: A Generalized Framework for Imputation-Assisted Randomization Tests
Requires Python: >=3.8

# I-ART: Imputation-Assisted Randomization Tests

## Description

I-ART (Imputation-Assisted Randomization Tests) is a Python package designed for conducting finite-population-exact randomization tests in design-based causal studies with missing outcomes. It offers a robust solution to handle missing data in causal inference, leveraging the potential outcomes framework and integrating various outcome imputation algorithms.

## Installation

To install I-ART, run the following command:

```bash
pip install causal-i-art
```

## Usage

Here is a basic example of how to use I-ART:

```python
import numpy as np
from i_art import iartest

Z = np.array([1, 1, 1, 1, 0, 0, 0, 0])
X = np.array([[5.1, 3.5], [4.9, np.nan], [4.7, 3.2], [4.5, np.nan], [7.2, 2.3], [8.6, 3.1], [6.0, 3.6], [8.4, 3.9]])
Y = np.array([[4.4, 0.5], [4.3, 0.7], [4.1, np.nan], [5.0, 0.4], [1.7, 0.1], [np.nan, 0.2], [1.4, np.nan], [1.7, 0.4]])
result = iartest(Z=Z, X=X, Y=Y, L=1000, verbose=True)
```

## Features

- Conducts finite-population-exact randomization tests.
- Handles missing data in causal inference studies.
- Supports various outcome imputation algorithms.
- Offers covariate adjustment in exact randomization tests.


## Contributing

Your contributions to I-ART are highly appreciated! If you're looking to contribute, we encourage you to open issues for any bugs or feature suggestions, or submit pull requests with your proposed changes. 

### Setting Up a Development Environment

To set up a development environment for contributing to I-ART, follow these steps:

```bash
python -m venv venv
source venv/bin/activate 
pip install -r requirements.txt
```
This creates a virtual environment (`venv`) for Python and activates it, allowing you to work on the package without affecting your global Python environment.

## License
This project is licensed under the MIT License

## Citation
If you use I-ART in your research, please consider citing it:

```code
@misc{heng2023designbased,
      title={Design-Based Causal Inference with Missing Outcomes: Missingness Mechanisms, Imputation-Assisted Randomization Tests, and Covariate Adjustment}, 
      author={Siyu Heng and Jiawei Zhang and Yang Feng},
      year={2023},
      eprint={2310.18556},
      archivePrefix={arXiv},
      primaryClass={stat.ME}
}
```
mathfuncs-parse 1.1.4
A small module for parsing and evaluating expressions of any number of variables


Mathfuncs Parse
===============

How to Use:
------------

After importing 'mathfuncs_parse', create a 'mathfuncs_parse.func(expr: str)' object.

Available Member Functions:
---------------------------

- ``valid() -> bool``
  Checks whether the expression is syntactically correct.

- ``eval() -> float``
  Evaluates the expression. Note: only works if no variables are present.

- ``eval(vars: dict{str: float|int}) -> float``
  Evaluates the expression, substituting the variables present with the values passed in the dict.

- ``vars() -> dict{str: float}``
  Returns a dict containing all variables that must be passed to eval().

- ``add_func(name: str, func: <functionObj(float) -> float>) -> Null``
  Adds a user-defined function to the object's internal state. Note: calling 'init(str)' does not reset this.

- ``avail_funcs() -> dict{str: <functionObj>}``
  Returns a dict of available functions which can be used in the current expression.

Release Note (1.1.3):
---------------------

- Updated compiler flag detection for building source wheels on most platforms

- Small bug fixes for greater cross-platform compatibility