semvec/pypi-packages huggingface dataset:
dependency-resolution 0.2.2
A simple dependency resolution library using container concepts
License: MIT
Requires Python: >=3.8.0,<4.0.0
Keywords: dependency,resolution,injection

# Dependency Resolution

## How to use

### ProviderCache Usage

When autowiring is not required use ProviderCache for a simple implementation.

Because autowiring is not involved there are algorithms to determine the order of initialization. And therefore ProviderCache is faster.

```python
from dependency_resolution import ProviderCache

class Image:
  def __init__(self, file: str):
    self.file = file

class ImageProcessor:
  def __init__(self, image: Image):
    self.image = image

  def sharpen(self):
    pass

def init_image():
  cache = ProviderCache.get_instance()
  cache += Image("image.png")
  # Can also be done like this
  # cache[Image] = Image("image.png")

def init_processor():
  cache = ProviderCache.get_instance()
  cache += ImageProcessor(cache[Image])

def process_image():
  cache = ProviderCache.get_instance()
  processor = cache[ImageProcessor]
  processor.sharpen()

if __name__ == "__main__":
  init_image()
  init_processor()
  process_image()
```

### AutoWiredCache Usage

When autowiring is required use AutoWiredCache.

AutoWiredCaches accept just the types of the dependencies and will automatically resolve them (given required deps are already present in the Cache or can be created using other deps).

```python
from dependency_resolution import AutoWiredCache

class ImageDriver:
  def __init__(self, proc: ImageProcessor, image: Image):
    self.proc = proc
    self.image = image

  def edit_and_save(self):
    pass

def init_image():
  cache = AutoWiredCache.get_instance()
  cache += Image("image.png")
  # Can also be done like this
  # cache[Image] = Image("image.png")

def init_processor_and_driver():
  cache = AutoWiredCache.get_instance()
  cache += ImageProcessor
  cache += ImageDriver

def process_image():
  cache = AutoWiredCache.get_instance()
  driver = cache[ImageDriver]
  driver.edit_and_save()

if __name__ == "__main__":
  init_image()
  init_processor()
  process_image()
```

`AutoWiredContainer` also supports lazy evaluation of dependencies. When a new type is added to the cache, it is not initialized immediately and as a result any missing deps will be ignored at that moment.

Therefore, `init_processor_and_driver` function from the above example can be as follows

```python
def init_processor_and_driver():
  cache = AutoWiredCache.get_instance()
  cache += ImageDriver
  cache += ImageProcessor
```

When the `ImageDriver` object is obtained from the cache (`cache[ImageDriver]`), the `ImageProcessor` object will be created first following which the `ImageDriver` object will be created.

## Future Plans

- [x] Add autowire support
- [ ] Add Providers to pass specific arguments to the constructor
- [ ] Add support for deleting or removing provided instances in both `ProviderCache` and `AutoWiredCache`
supu 0.1.0
Slightly Useful Python Utility functions
License: MIT
Requires Python: >=3.8,<3.12

# SUPU

Slightly Useful Python Utilities – a grab bag of small functions

These are really more like gists, but in a place where I can test them; if you want to
use them, it might just be easier to copy them into your own code than to add `supu` as
a dependency.
thinks-dash-alert 1.0.0
Dash Alert Component
License: MIT

# Thinks Dash Alert

Thinks Dash Alert is a Dash component library.
Alert component for Dash.

### Installation
***

    $ pip install thinks_dash_alert


### Properties
***

- id (string)
- message (dash component; require)

    Message to be displayed in the alert.

- title: (dash component)

    Alert Title.

- buttons: (list[dict])

    Button list for alerts.

    - title (string; require)

        Button Title.

    - value (string | int | float; require)

        Value returned when a button is pressed.

    - color (string)

        Button theme color

- value (string | int | float; readonly)

    Value of button pressed.

- is_open (bool)

    Alerts are open or not.

- duration (int)

    Drawing time for opening and closing animation (milliseconds).

- output_target

    For targets in Output. Does not affect anything internally.
CI-tartanair 588245082195
TartanAir
License: MIT
Requires Python: >=3.7
Keywords: conversion

# TartanAir

Hello and welcome to the official TartanAir repository. This repository includes a set of tools that complement the [TartanAir Dataset](https://www.tartanair.org/)). 

# Dear developers please read this.
To be able to run our tests and the package overall, while we are still developing it, please create a `.txt` file somewhere with an Azure access token, and point `src/tartanair/taratanair_module.py` to it. Look for the place to do that at the bottom of the file. This is a temporary solution and will be changed as soon as we move the data to a public blob.


## Installation
```
pip install tartanair
```

## Usage
```
from tartanair import TartanAir
ta = TartanAir()
```

## Examples
You may run the examples provided in the `examples` folder. One option for trying those out directly is to clone the repository and run the following command from the examples directory:
```
$ cd examples
$ python3 <example_name>.py
```

**Notice: The examples, when run directly from a cloned repo, require the `tartanair` package to be uninstalled if already installed. This may be changed soon but for now please only have one copy of the package.**


## Citation
If you use this dataset, please cite the following paper:
<!-- TODO(yoraish) -->
```
@inproceedings{wang2023pip,
  title={pip install tartanair: },
  author={},
  booktitle={},
  year={2023}
}
```

## License
MIT License. 

## Contributing.
The structure of the repository is as follows:
```
src
├── tartanair
│   ├── tartanair_module.py # Super class for all modules. Each module is instantiated in the TartanAir class.
│   ├── downloader.py
│   ├── visualizer.py
│   ├── customizer.py
│   ├── ...
│   └── __init__.py

tests
├── test_downloader.py
├── test_visualizer.py
├── test_customizer.py
└── ...

examples
├── example_downloader.py
├── example_visualizer.py
├── example_customizer.py
└── ...
```

Please add contribution of new modules as follows. Let's use an example of a new module for underwatering the dataset. This would implement the method `tartanair.underwaterify()` and would make everything in the dataset look like it was taken underwater. Do we want to do this? Yes. But let's pretend we don't.

1. Create a new module in `src/tartanair`, in our case `underwaterifyer.py`.
2. In `src/tartanair/underwaterifyer.py`, create a class `TartanAirUnderwaterifyer` that inherits from `TartanAirModule`. This class should implement the method `underwaterify()`.
3. In `src/tartanair/tartanair.py`, instantiate the class `TartanAirUnderwaterifyer` in the `__init__()` method of the `TartanAir` class and add the method `underwaterify()` that calls the method `underwaterify()` of the `TartanAirUnderwaterifyer` class.
4. Add tests for the new module in `tests/test_underwaterifyer.py`.
5. Add an example for the new module in `examples/example_underwaterifyer.py`.