semvec/pypi-packages huggingface dataset:
dwave-tuner 0.0.4
Tune D-Wave QPU solver parameters
Requires Python: >=3.7

# D-Wave Tuner

`dwave-tuner` simplifies the process of tuning annealing parameters, allowing
you to concentrate on your model and specific problem. Simply specify the
number of embeddings, chain strengths, and annealing times, and watch as
dwave-tuner tailors the tuning experience to your needs.

## Features
- **Effortless parameter tuning**: Grid scan chain strengths and annealing
  times with a given number of embeddings.
- **Caching for efficiency**: D-Wave responses are cached by default, enhancing 
  performance by utilizing cached results unless you modify the scan or alter
  the parameters.
- **User-Friendly**: Minimal configuration; just specify your preferences in a
  dictionary, and let `dwave-tuner` handle the details.

## Example Usage
```python
import dwavetuner
```

Specify the scan parameters:
```python
parameters = {
    'num_embeddings': 10,
    'num_chain_strengths': 1,
    'num_reads': 1000,
    'num_reps': 1
}
```

Create a `Scanner` to schedule the `Job`s:
```python
scanner = dwavetuner.Scanner(my_model.bqm, label='my_model', **parameters)
```

Perform a grid scan
```python
scanner.grid_scan()
```

The grid scan stores the results in `scanner.results`. It returns a response
that can also be accessed via
```python
print(scanner.response)
```

The verbose tuning data can be accessed via
```python
x, ys, yerrs = scanner.scan_results('chain_strength')
```

For annealing time scans, replace `chain_strength` with `annealing_time`.

Note that `x` is one list, while `ys` an `yerrs` contain
`scanner.num_embeddings` lists - one for each embedding.

Alternatively, use these self-explanatory `parameters`:
```python
# Scan chain strengths
parameters = {
    'num_embeddings': 10,
    'chain_strengths_start': 0.24,
    'chain_strengths_end': 0.44,
    'num_chain_strengths': 10,
    'num_reads': 100,
    'num_reps': 1
}

# Scan annealing times
parameters = {
    'chain_strength': 0.28,
    'num_annealing_times': 10,
    'num_reads': 100,
    'num_reps': 5
}
```

## Author

Orkun Şensebat

git@senseb.at
baseten 0.8.2
Deploy machine learning models to Baseten
Requires Python: >=3.8,<3.12
Keywords: MLOps,AI,Model Serving,Model Deployment,Machine Learning

# Baseten

This is the Python client for [Baseten](https://baseten.co) and [Blueprint](https://blueprint.baseten.co).

## Installation

Install the latest version of the `baseten` package:

```sh
pip install --upgrade baseten
```

## Baseten

Baseten is a hosted platform for building ML-powered applications. Build apps with auto-scaling, GPU access, CRON jobs, and serverless functions.

Visit our official documentation for Baseten at [docs.baseten.co](https://docs.baseten.co).

## Blueprint

Blueprint is the model fine-tuning and serving infrastructure for developers. It's powered by Baseten infrastructure and uses the baseten PyPi package.

Visit our official documentation for Blueprint at [docs.blueprint.baseten.co](https://docs.blueprint.baseten.co).
simplekivy 0.0.7
the idea is inspired by PySimpleGui , to quickly create simple kivy apps
Requires Python: >=3.7

# SimpleKivy

```bash
pip install simplekivy
```

### Do not forget to install:
-------
* [kivy]("https://pypi.org/project/Kivy") 
* [kivymd]("https://github.com/kivymd/KivyMD") `master branch is recommended`


simplekivy is built with kivy to write quickly simple codes

you can write kvlang and creat your own classes and widgets as kivy is flexible

the widgets are added only once via simpleKivyObject + [

#kv_widgets

]

and you can build simplekivy way using `s.build`

### Examples to test:
-----

```python
from simplekivy import SimpleKivy
s = SimpleKivy(title="test app")
dp = s.metrics.dp

def pressed(instance):
    if text_input.text:
        label.text = text_input.text

background = """
BoxLayout:
    canvas:
        Color:
            rgba: 0, 0, .9, .7
        Rectangle:
            pos: self.pos
            size: self.size

"""

text_input =  s.STextInput(hint_text="type", size_hint=(.5, None), height=dp(60), pos_hint={"center_x":.5})
btn = s.SButton(text = "click", size_hint=(.4, .2), pos_hint={"center_x":.5, "center_y":.5}, on_press=pressed)
label =  s.SLabel(text = "type")

# you don't really need to build here and can just pass the list .. 
# but iam showing you how to get objets using s.build
# so you may need it somewhere else
front = s.build([{"orientation":"vertical"},
                text_input,
                (btn,),
                label            
])

s + [(background,
front
)
]

```

```python

from simplekivy import SimpleKivy
s = SimpleKivy(title="test app")
screen_manager = s.ScreenManager()

class ScreenI(s.Screen):
    def left(self):
        print("------", self, self.name)
        screen_manager.transition.direction = "right"
        screen_manager.current = screen_manager.previous()

    def right(self):
        print("------", self, self.name)
        screen_manager.transition.direction = "left"
        screen_manager.current = screen_manager.next()

manager = {screen_manager: None}
scr = {}

for i in range(4):
    left = s.SButton(text="left")
    right = s.SButton(text="right")
    screen = ScreenI(name=str(i))
    left.on_press = screen.left
    right.on_press = screen.right
    scr[screen] = [{"orientation":"vertical"},s.SLabel(text=str(i)),[ left, right]]

manager[screen_manager] = scr
s + [
    manager
]

```
### Hints
------

- list => BoxLayout
- tuple => FloatLayout
- set `make_app` to `False` if you do not want to run the kivy App 
```python
s = SimpleKivy(make_app=False)
```
- to reach the main App object do `s.myapp`
- you can pass to `s.build` a `list, tuple, dict, set and kivy lang string`
- the more you understand kivy, the more you enjoy its flexibility

----


<img src="https://github.com/yousuf60/SimpleKivy/assets/64571068/5905a746-8278-4471-b1e3-d85b7eb5eec6" width="400">


<img src="https://github.com/yousuf60/SimpleKivy/assets/64571068/f2abb219-55c1-4e9e-a9e9-e46346d6176f" width="400">