semvec/pypi-packages huggingface dataset:
exsu 0.6.0
Experiment support tools
License: MIT

  
[![Build Status](https://travis-ci.org/mjirik/exsu.svg?branch=master)](https://travis-ci.org/mjirik/exsu)
[![Coverage Status](https://coveralls.io/repos/github/mjirik/exsu/badge.svg?branch=master)](https://coveralls.io/github/mjirik/exsu?branch=master)
[![PyPI version](https://badge.fury.io/py/exsu.svg)](http://badge.fury.io/py/exsu)


# exsu

Experiment support tools prepared for computer vision experiments. 
Output directory and spreadsheet file is managed by package.

* Spreadsheet data and report images are stored into output directory
* Images are reported according a selected severity
* Common spreadseet containing complete history from all output directories can be produced
* Version of particular python package can be reported in the spreadsheet
* Repository status, git hash and dirty files can be reported in the spreadsheet

## Write spreadsheet data

```python
from pathlib import Path
import exsu

outputdir = Path("./test_report/")
commonsheet = Path("./test_report_common_spreadsheet.xlsx")

report = exsu.report.Report(outputdir=outputdir, additional_spreadsheet_fn=commonsheet)
report.add_cols_to_actual_row({"Col1": 25, "Col2": "test string", "Col5": 5})
report.add_cols_to_actual_row({"Col2": "prepsanu", "Col1": 26, "Col4": "ctyrka"})
report.finish_actual_row()

report.add_cols_to_actual_row({"Col1": 27, "Col2": "test string", "Col3": "trojka"})
report.finish_actual_row()

# Save all into `outputdir` and also into `commonsheet`
report.dump()

# new write to common excel
report.init()
report.add_cols_to_actual_row({"Col1": 28, "Col2": "new line to common", "Col7": 77})
report.finish_actual_row()
report.dump()

```

## Write image data

Write image data into output directory

```python
from pathlib import Path
import numpy as np
import exsu

outputdir = Path("./test_report/")
commonsheet = Path("./test_report_common_spreadsheet.xlsx")

fn = "test_image.png"
img = 50 + np.random.rand(100, 100) * 30
img[20:60, 20:60] += 100
img = img.astype(np.uint8)
report = exsu.report.Report(outputdir=outputdir, additional_spreadsheet_fn=commonsheet)
report.imsave(fn, img)
```


## Git repository info

```python
from pathlib import Path
import numpy as np
import exsu
report = exsu.report.Report(repodir=Path(__file__).parent.resolve())
report.finish_actual_row()
report.df
```
Output DataFrame
```
                               repo exsu id  ...  repo exsu dirty files
0  1da301da36cec0fb931f60dd9acca790ec715892  ...      exsu/git_tools.py
```

More than one repositories can be added with `report.add_repo(repodir, reponame=None)`.


## Automatically report versions of selected packages

The version of crucial packages can be reported with the data.

```python
import exsu
report = exsu.report.Report(check_version_of=["numpy", "scipy"])
report.finish_actual_row()
report.df

```
pytoimage 0.0.1
Transform your Python code in an image.
License: MIT
Requires Python: >=3
Keywords: image code custom theme color palette

# pytoimage

*Note: pytoimage is still in its initial stages, for now, you can normally transform your code in an image, choosing the backgroud and the text color. But, all code is currently with a single color, not differentiating anything, such as keywords, strings, functions... this will come in future versions.*

## Download

You can simply:

```sh
pip install pytoimage
```

Or you can also:

1. Clone the repository to your local machine.
2. Enter the directory.
3. Download necessary modules/libraries.

```sh
git clone https://github.com/gabrielstork/pytoimage.git
cd pytoimage
pip install -r requirements.txt
```

## Example

```python
from pytoimage import PyImage
```

The **PyImage** class has three parameters: **path** (the Python code path), **background** (*optional*, the background color of the image) and **font** (*optional*, the path of a **.ttf** font).

```python
code = PyImage('pytoimage/pytoimage.py', background=(15, 15, 15), font='fonts/Inconsolata.ttf')
```

The following method is optional, it allows you customize the theme of your image (*see initial note*).

```python
palette = {
    'line': (149, 149, 149),
    'normal': (255, 255, 255),
}

code.set_color_palette(palette=palette)
```

To generate the image, you can simply call the method with no arguments, the **start** and **end** are optionals, these are the code intervals.

```python
code.generate_image(start=39, end=51)
```

Then you can see and save the generated image.

```python
code.show_image()
```

![Example](https://raw.githubusercontent.com/gabrielstork/pytoimage/main/images/example.png?token=AUUMP4TZFVIWGTGZPVBE4FLBGYFAM)


```python
code.save_image('images/example.png')
```

[![forthebadge](https://forthebadge.com/images/badges/made-with-python.svg)](https://github.com/gabrielstork)
[![forthebadge](https://forthebadge.com/images/badges/built-with-love.svg)](https://github.com/gabrielstork)
oshi 0.1.0
An asynchronous osu API wrapper written in python
License: MIT
Requires Python: >=3.9,<4.0
Keywords: osu

# oshi
An asynchronous osu API wrapper made in python 

## Example(s)

   ```py
   import oshi
   import asyncio


   async def main() -> None:
      auth = oshi.Authentication(CLIENT_ID, "CLIENT_SECRET")

      async with oshi.Client(auth) as client:
         map = await client.get_beatmap(id=1222063)
         print(map.url)

   asyncio.run(main())
   ```


## Development
_For developers_
If you plan on contributing please open an issue beforehand

## Contributors

- [an-dyy](https://github.com/an-dyy) - creator and maintainer
tracematrix 1.0.1
Tool to create a traceability matrix
License: MIT
Requires Python: >=3.6.2,<4.0.0
Keywords: requirements,traceability,testing,requirements engineering

# tracematrix
A Python tool to create a traceability matrix.

## Scope
This package focuses on generating the traceability matrix itself.
As the APIs and export formats of different test management and/or requirement management tools can be very different, the data acquisition and conversion is not in the scope of this package. However, it aims to provide a convenient way to create the individual items (e.g. requirements, testcases or any other traceable item) and traces between them.

## How to use this package
Currently it is only possible to use this package programmatically in your own script.

You start by creating an instance of ``TraceabilityMatrix``.
The output format is controlled by the ``reporter`` parameter.
By default ``CsvReporter`` is used, but you can also generate HTML output by passing ``HtmlReporter``.
```Python
from tracematrix.matrix import TraceabilityMatrix
from tracematrix.reporters import HtmlReporter

matrix = TraceabilityMatrix(reporter=HtmlReporter)
```

In the next step you add rows and columns to the ``matrix``. Rows and columns can represent anything
which may be traced against each other. Let's assume that we want to see traces between requirements and test cases.
This is where your own logic comes into play - the way you determine which items exist and what is traced against each other is up to you and what the source of your data is. For this example, we just use some hardcoded values.
```Python
for testcase_id in ("TC_1", "TC_2", "TC_3"):
    matrix.add_row(testcase_id)
for requirement_id in ("REQ_1", "REQ_2", "REQ_3", "REQ_4"):
    matrix.add_column(requirement_id)

matrix.add_trace("TC_1", "REQ_1")
matrix.add_trace("TC_2", "REQ_2")
matrix.add_trace("TC_2", "REQ_3")
```
Note that rows and columns must be unique - you cannot have two rows or two columns with the same ``id``.
When you add a trace between a row and a column, the ``TraceabilityMatrix`` will look up the corresponding
``TraceItem`` instances itself.

Finally, you can save the output to disk:
```Python
matrix.write_matrix("traceability_matrix.html)
```

# Changelog

## V1.0.1
### Fixes
* Remove empty lines in CSV output on windows
  Closes #2

## V1.0.0
### API changes:
* ``TraceItem`` has been degraded to a simple dataclass. The methods ``get_by_id`` and ``add_trace`` have been removed. Adding items (rows or columns) to a ``TraceabilityMatrix`` is now done by using ``TraceabilityMatrix.add_row(row_id)`` and ``TraceabilityMatrix.add_column(column_id)``. Traces between rows and columns are created by calling ``TraceabilityMatrix.add_trace(row_id, column_id)``. To all these methods, the ``id`` is passed as a string. The end user does not need to work with the ``TraceItem`` class any more.
bookmarkdown 0.1.1
Parse your browser's exported HTML bookmark file to Markdown.
License: MIT
Requires Python: >=3.7,<4.0
Keywords: bookmarks,markdown,parser

# bookmarkdown

Parse your browser's exported HTML bookmark file to Markdown.

Supported browsers: Brave.

## Installation

```bash
pip install bookmarkdown
```

## Usage

### CLI

```bash
# Convert "bookmarks.html" to markdown and output to STDOUT
btm bookmarks.html

# Convert "bookmarks.html" to markdown and write to "bookmarks.md"
btm --output=bookmarks.md bookmarks.html

# Alternatively
btm bookmarks.html > bookmarks.md
```

### Python

The `BookmarkHTMLParser` is an instance of the Python standard library's
[`HTMLParser`](https://docs.python.org/3/library/html.parser.html) and thus supports all its
methods.

```python
from bookmarkdown import btm

parser = btm.BookmarkHTMLParser()
parser.feed(html_content)

# Access the data
parser.data
```

## FAQ

### Concerns

* Minimal dependencies. `bookmarkdown` is likely to be installed on the system level Python to make
  use of the `btm` script.
* Correctness. No one likes to lose a bookmark nor a different ordering.

### Future ideas

> The current application solves my needs pretty well, but there are additional applications I can
> think of. Such as merging multiple bookmark files.

Add functionality to the CLI and Python codebase to support the following:

```bash
# Merge bookmark html-file into existing markdown file.
btm --merge=[md-file] [html-file]

btm [html-file]  # already implemented

# Read the `-r` as "reverse", i.e. instead of bookmark to markdown it
# becomes markdown to bookmark.
btm -r [md-file]

btm -r --merge=[md-file] [html-file]
```

### Project structure

The project structure was automatically set up using `cookiecutter` and my Python template:
[cutter-py](https://github.com/yannickperrenet/cutter-py).