semvec/pypi-packages huggingface dataset:
sgm-data 0.5.0b0
Module for loading, interpolating and plotting data taken at the SGM Beamline at the Canadian Light Source.
License: MIT

# Helper module for working with data from the [SGM Beamline](https://sgm.lightsource.ca) 
### Installation:
Using pip:
```commandline
pip install sgm-data
```
or from source: 
```commandline
git clone https://github.lightsource.ca/arthurz/sgmdata ./sgmdata
cd sgmdata
python setup.py install
```
### Usage:
First import the package, and select data to load in.
```python
import sgmdata 
data = sgmdata.SGMData(["file1.hdf5", "file2.hdf5", "..."])
```
This will identify the independent axis, signals and other data within the files listed. 
The file load list also works with [hsds](https://github.com/HDFGroup/hsds) domains.
```python
data = sgmdata.SGMData(["file1.data.sgm-hdf5.lightsource.ca", "..."])
```
Useful functions:
```python
data.scans  #contains a dictionary of the identified data arrays loaded from your file list
data.interpolate(start=270, stop=2000, resolution=0.5) #bin the data in scans dictionary and interpolates missing points
data.mean() #average data with the same sample name, and spec command together. 
```
Working with individual scans:
```python
df = data.scans['FilePrefix'].entry1.interpolate(start=270, stop=2000, resolution=0.1) #bin data for a single scan.
df2 = data.scans['FilePrefix'].entry1.fit_mcas() #perform batch gaussian fitting of interpolated SDD signal
```
Plotting (with [Bokeh](https://docs.bokeh.org/en/latest/index.html)):
```python
data.scans['FilePrefix'].entry1.plot()
data.average.plot()
```
spellsync 0.2.0
Synchronise personal spelling dictionaries across applications
License: MIT
Requires Python: >=3.9,<4.0

# Introduction

This utility synchronises spelling dictionaries from various tools with each other. This way the words that have been trained on MS Office are also correctly checked in vim or Firefox. And vice versa of course.

# Supported tools

The initial supported tools are:

-   AppleSpell (Mac OS built-in spelling)
-   Microsoft Office (Mac)
-   Mozilla Firefox (Mac)
-   Mozilla Thunderbird (Mac)
-   aspell
-   neovim - adjusting for vim would be trivial though

# Process

SpellSync accomplishes this work by reading all the stored words from all the dictionaries. It stores that dictionary in a central location. From there the individual app dictionaries are updated with the merged list.

# Installation

SpellSync is created in Python and published on Python's PyPI. Installation in most cases is accomplished with the following command:

    pip install spellsync

# Usage

Once set up, you can do a dry-run of `spellsync` with the following command:

    spellsync -n

This will show how large the common dictionary will become, but no files are written.

To execute the sync in live mode, run without the `-n` option:

    spellsync

## Recovering from Errors

By default a backup of all spelling files is created in the `spellsync` folder inside the XDG state home (default location is `~/.local/state/spellsync`). So if anything goes awry, you can use the backup files from there. The path to the dictionary files that are modified is output when the command is run, which should aid in finding out where the files would have to be moved back to.

Note that the backup folder is not cleaned out or rotated. So if you run the script regularly, the folder may grow too large. You can then either manually clear out old backup files (`tmpwatch` may be helpful here) or you can disable the backup altogether:

    spellsync --no-backup
greek-alphabet 1.0
Provides the Greek Alphabet and utility functions to manipulate it
License: MIT

# Greek Alphabet
A Python module for working with the Greek alphabet.

## Usage
### Importing the module
```python
from greek_alphabet import Alphabet
```

### Getting a list of all Greek alphabet characters
```python 
alphabet_list = Alphabet.get_list()
```

### Getting a dictionary of all Greek alphabet characters
```python
alphabet_dict = greek_alphabet.Alphabet.get_dict()
```

The `get_dict()` method takes two optional parameters:

- `key`: a function that takes an `AlphabetChar` object and returns a string to use as the dictionary key. By default, the Greek name of the character is used.
- `value`: a function that takes an `AlphabetChar` object and returns the value to use in the dictionary. By default, the `AlphabetChar` object is used.

### Converting between upper and lower case
```python 
# Convert a lower case letter to upper case
upper_case_char = greek_alphabet.Alphabet.upper('a')

# Convert an upper case letter to lower case
lower_case_char = greek_alphabet.Alphabet.lower('Γ')
```


## AlphabetChar class
The `AlphabetChar` class represents a single character of the Greek alphabet. It has the following attributes:

- `char`: the character itself
- `capitalized`: the capitalized version of the character
- `name`: the name of the character in Greek
- `lower`: the lower case equivalent of the character

# License
This module is released under the MIT License. See LICENSE for more information.