semvec/pypi-packages huggingface dataset:
blog-app 0.1.3
A simple blog application with Flask
Requires Python: >=3.11

# Blog Application

A simple blog application built with Flask.

## Features

- View all blog posts
- Add new posts
- Automatic timestamps for each post

## Package Structure

```
blog-app/
├── __init__.py
├── config.py
├── database.py
└── posts.py
```

## Setup with PyPI Package

1. Install the package
    ```bash
    pip install blog-app
    ```

2. Run the application
    ```bash
    python blog-app
    ```
   
3. Done
   - The API will be available at `http://localhost:5000`

## Setup with Source Code

1. Clone the repository
    ```bash
    git https://gitlab.com/y.karzal/2024_assignment2_blogpss
    cd 2024_assignment2_blogpss
    ```

2. Set up the application
    ```bash
    python -m venv .venv
    source .venv/bin/activate
    pip install -r requirements.txt
    ```

3. Run the application
    ```bash
    python run.py
    ```

4. Done
   - The API will be available at `http://localhost:5000`

## Testing (Unit and Integration) with Source Code

install pytest:
```bash
pip install pytest
```

Run backend unit tests:
```bash
pytest tests/unit
```

Run backend integration tests:
```bash
pytest tests/integration
```
anubisgit 0.7.0
Anubis, a CodeMetrics helper
Requires Python: >=3.7
Keywords: code metrics, code analysis


![Anubis](https://images.unsplash.com/photo-1595853899417-4cc421f2998e?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=2072&q=80)


# Anubis, a codemetrics tool.

You can read more about anubisgit on the [internal docummentation page page](http://open-source.pg.cerfacs.fr/anubisgit/).


##### Work in progress

Today, Anubis is essentially the script `timemachine.py`.
the time machine is a loop can spawn various versions  of a code from its gitbase, and perform analysis on it

##### Installation

Anubis I under fast development, and we do not update PiPY very often.
For a quick installation in a simplified virtual environment

```bash
python3 -m venv venv_anubisgit
source venv_anubisgit/bin/activate
python -m pip install 'anubisgit @ git+https://gitlab.com/cerfacs/anubisgit.git'
```

You can obiously install it from the sources available on [gitlab.com](https://gitlab.com/cerfacs/anubisgit)

##### main Usage

For now , there is a minimal CLI, limited to the execution of the time machine of Anubis
Type `>anubisgit` to see what is available :

```bash
 >anubisgit
Usage: anubisgit [OPTIONS] COMMAND [ARGS]...

  Package anubisgit v0.7.0

  ---------------    Anubis  --------------------

      You are now using the Command line interface of anubisgit package,     a
      set of tools created at CERFACS (https://cerfacs.fr).

      This is a python package currently installed in your python
      environement.

Options:
  --help  Show this message and exit.

Commands:
  anew          Create a default input file in current folder.
  authors-list  Retrieve authors list from joined_commits_monthly.json
  branches      Analyze branch health
  chronology    Code geology
  complexity    Analyse code health
  join-db       Join Anubis database
  timemachine   Build anubisgit database
```

If your new to anubisgit, you can find a quick how to tutorial [there](/docs/howto/howto_anubisgit.md)

##### Good practice

Althought anubisgit timemachine cli command won't let you start a run if your repository is not clean. It is highly recommended to git clone the repository you want to analyze and have a repository for your work repository to avoid any unwanted behaviour or file deletion during the timemachine process.


##### Most common troubleshoots

- Unclean repository
- .gitignore
  
##### Acknowledgements

![coec](https://www.hpccoe.eu/wp-content/uploads/elementor/thumbs/COEC_LOGO_RGB-01-pfvgeiplphmisuon437fk53iowou3j66yoeidghma6.png)

This work has been initially supported by the [COEC project](https://www.hpccoe.eu/coec/) which has received funding from the European Union’s Horizon 2020 research and innovation program under grant agreement No 952181 .
spyder-watchlist 2.0.0rc0
Watchlist plugin for the debugger in the Spyder IDE
Requires Python: >=3.7
Keywords: Spyder, watchlist, debugger

# Spyder Watchlist plugin

Watchlist plugin for the debugger in the Spyder IDE

A watchlist is a functionality some IDEs offer while debugging code. It is
related to the display of all variables accessible in the current scope (aka
Variable Explorer in Spyder). But there is an important distinction: A Watchlist
consists of a user-definable list of expressions. These expressions are
evaluated after each debugger step and the result of the evaluation is
displayed. See [here](https://github.com/spyder-ide/spyder/issues/16438) for a
screencast which demonstrates the plugin.


## Installation

    pip install spyder-watchlist

## Features

* Any Python expression can be entered. The Watchlist displays the stringified
  result of the evaluation. In terms of Python code `value =
  str(eval(expression, globals, locals))`.

  > **Warning**
  > This makes the Watchlist a very powerful tool, but this comes at a cost: Any
  > side effects of an expression will affect your execution environment.

* The values of expressions are refreshed whenever they might have changed
  (after executing commands in the IPython Console and after debugger commands).
* The list of expressions can be modified at any time; see [Usage](#usage) for
  details.
* The value of an expression is shown with bold font if it has changed
* The value of an invalid expression is show as `<exception name>`. Hover the
  mouse over the value to show the full exception message in a tooltip.

## Usage

* Rearranging of expressions: Use Drag & Drop
* Changing an existing expression: Double click on expression (first column)
* Adding a new expression
  * Toolbar `+` button
  * Menu entry in right-click menu (anywhere in the table)
  * Double click at the end of the table (only possible if there is no
    scrollbar)
  * Drag & Drop text. If the text consists of multiple lines, each line is added
    as an expression.
* Removing expressions. The following actions remove the currently selected
  expressions:
  * Toolbar `-` button
  * Menu entry in right-click menu
  * `Del` keyboard key
* There is also a “Remove all expression” action in the toolbar and right-click
  menu

## Known Issues

* The value of variables in the current scope can be changed in Spyder’s
  Variable Explorer plugin. Expressions in the Watchlist depending on any
  variable changed in the Variable Explorer will display an outdated value. The
  new expression value is displayed after a refresh of the Watchlist. A
  refresh is trigged by:
  * Executing commands in the IPython Console. Pressing Enter with an empty
    input prompt is sufficient.
  * Modifying the list of expressions in some way (add, remove or edit an
    expression)
pylote 1.1.0
Client Python pour interagir avec l'API Pilote (DITP).
Requires Python: >=3.8

# Pylote

Ce code permet d'interroger l'API de Pilote pour exporter et importer des données.

## Installation

Installer les dépendences dans un environnement virtuel avec `pip install .`.

## Usage

Exemple d'utilisation:

```python

# [init] Initialisation de l'objet Pylote
pilote = Pylote(environ.get("BASE_URL"), environ.get("API_KEY"))

# [export]
## [export] Export des données de IND-208
donnees_208 = pilote.get_donnees_indicateur("CH-047", "IND-208")

# [export]
## [export] Export des données du chantier CH-080
chantier_080 = pilote.get_donnees_chantier("CH-080")

# [import]
## [import] Import de données d'une liste Python
data_to_import = [
    {"identifiant_indic": "IND-208", "zone_id": "D01", "zone_nom": None, "date_valeur": "2024-07-15", "type_valeur": "va", "valeur": 12.64},
    {"identifiant_indic": "IND-208", "zone_id": "D01", "zone_nom": None, "date_valeur": "2022-12-01", "type_valeur": "vi", "valeur": 11.17},
]
pilote.import_donnees_indicateur_array("CH-047", "IND-208", data_to_import)

# [import] Import de données d'un fichier CSV
pilote.import_donnees_indicateur_file("CH-047", "IND-208", "./data-ind208-import-sample.csv", is_excel=False)
```

## Exemples

Des fichiers d'exemple fonctionnels sont mis à disposition dans le dossier [examples](./examples). Plus de détails dans README correspondant [examples/README.md](./examples/README.md).
fastlbp-imbg 0.2.1
Parallel multiradial LBP features
Requires Python: >=3.11
Keywords: lbp, texture, features, image processing, parallel

# fastLBP
Highly parallel LBP implementation

> **Important pre-release warning**:
> If aborted mid-execution, this software sometimes create a lot of orphan processes that needs to be killed manually.
> Please, note down the name of your python script, search for `Python` in your task manager and look for the processes that correspond to your python script.

## Requirements
FastLBP is tested with Python 3.11 on Windows 10, Debian 11, and Ubuntu 22.04

Python requirements are:
- numpy >= 1.26.0
- Cython (to build the binary modules, will be optional in the future)
- scikit-image >= 0.22.0 (mostly for testing, we plan making this requirement optional in the future)
- pandas >= 2.1.1
- psutil

## Installation

- Activate or create a Python 3.11 environment (e.g. using `conda create -y -n p11 python=3.11 && conda activate p11`)
- Verify you are using the right env
	- `python --version` and `pip --version`
- Install a stable version from PyPI  
	`pip install fastlbp-imbg`
- Or build the latest version from sources  
	```
	git clone git@github.com:imbg-ua/fastLBP.git
	cd fastLBP
	# git checkout <branchname> # if you need a specific branch
	pip install . # this will install the fastlbp_imbg package in the current env
	```
- You can use `import fastlbp_imbg as fastlbp` now

## Testing
```
# in repo root
conda activate fastlbp
pip install -e .
python -m unittest
```

## Bug reporting
You can report a bug or suggest an improvement using [our github issues](https://github.com/imbg-ua/fastLBP/issues)

## Implemented modules
### run_fastlbp
Computes multiradial LBP of a single multichannel image in a parallel fashion.

Features:
- Powered by `fastlbp_imbg.lbp`, our implementation of `skimage.feature.local_binary_pattern`
- Concurrency is managed by Python's [`multiprocessing`](https://docs.python.org/3/library/multiprocessing.html) module
- Parallel computation via `multiprocessing.Pool` of size `ncpus`
- Efficient memory usage via  `multiprocessing.shared_memory` to make sure processes do not create redundant copies of data
- If `save_intermediate_results=False` then computes everything in RAM, no filesystem usage

TODO: 
- Use `max_ram` parameter to estimate optimal number of sub-processes and collect memory stats. Now `max_ram` **is ignored**.

## Planned modules
### run_chunked_skimage
Similar to [1. run_fastlbp](#1-run_fastlbp), but each subprocess should compute LBP for its image chunk, not the whole image.

### run_dask and run_chunked_dask
Similar to [1. run_fastlbp](#1-run_fastlbp), but use [Dask](https://docs.dask.org/en/stable/) and [`dask.array.map_overlap`](https://docs.dask.org/en/stable/generated/dask.array.map_overlap.html#dask.array.map_overlap) for parallelisation instead of `multiprocessing` and manual data wrangling