semvec/pypi-packages huggingface dataset:
m2lk 0.0.2
WotLK M2 files parser
Requires Python: >=3.6

# m2lk
WotLK M2 files parser

```python
from m2lk import M2FileReader, M2, M2Skin

with M2FileReader(filename) as reader:
    m2 = M2()
    m2.load(reader)

with M2FileReader(skin_filename) as reader:
    skin = M2Skin()
    skin.load(reader)
```
And then `m2` can be used as a [structure](#M2Struct).

### M2Field
Feild's value can be obtained with `value` property. For example:
```python
m2.value
m2.name.value
```
The value is a JSON-srializable data.

### M2ArrayField
M2ArrayField is a subclass of M2Field. Its item can be obtained by index. For example:
```python
if len(m2.sequences) > 0:
    sequence_0_field = m2.sequences[0]  # M2Field instance
    sequence_0_field.movespeed.value  # float
```

### M2Struct
M2Struct is a subclass of M2Field.

`fields` property is a dict `{field_name: field}`.
For example M2 structure fields can be obtained with `list(m2.fields)`.

Structure field can be obtained by attribute: `getattr(obj, field_name)`. For example:
```python
sequences_field = m2.sequences  # M2ArrayField
```

Structure field's value can be obtained by name: `obj[field_name]`.
For example JSON-serializable value of `sequences` field:
```python
sequences_value = m2['sequences']  # The same as m2.sequences.value
```

Note: `M2` and `M2Skin` are subclasses of `M2Struct`.

### JSON
A m2 value can be saved to a json file:
```python
import json
m2_json = json.dumps(m2.value)
```

And then loaded to a M2 structure:
```python
m2 = M2()
m2.from_json(json.loads(m2_json))
```

The same is for M2Skin:
```python
import json
skin_json = json.dumps(skin.value)
skin_new = M2Skin()
skin_new.from_json(json.loads(skin_json))
```
gpx-geojson-py 0.0.1
gpx_geojson_py gives you the ability to extract data from gpx files and transform them into geojson format.
Requires Python: >=3.6

# gpx-to-geojson

A python library for transforming GPX data to GeoJSON format.
It also gives you the ability to extract data from the gpx file such as:
Total elevation, total distance, starting point, paired data.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.

```bash
pip install gpx-to-geojson
```

## Usage

```python
from gpx_geojson_py import GeoJsonTransformer

# Create an object from a gpx file.
gpxfile = GeoJsonTransformer(path='path/to/my_gpx_file.gpx') 

# Returns the total distance between each point in the gpx file.
gpxfile.total_distance

# Returns the total cumulative elevation between each point in the gpx file.
gpxfile.total_elevation

# Returns the first lat/lon pair found in the file.
gpxfile.starting_point
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)
char-count-example-pkg-asomchik 0.1.0
Char counting test package
Requires Python: >=3.6

**Introduction**

A small test package providing function which counts a number of one time appearing characters in a string or file given.

**Features**
- You can use command line interface in a usual Python way:

\>>> python char_count.py [-h] [-f FILE] [-s STRING]
- Or you can simply *import* char_count() function to your project
ftp-loader 0.2.2
A package to download project data files from FTP
Requires Python: >=3.5

# FTP Data Loader

ftp-loader is a tool to download from and upload data files to FTP server.
It is intended to use in projects with large data files. Data files are bad 
candidates for version control managment systems. They are better to be placed
at FTP server and be downloaded on demand. 

The suggested workflow is the following. Data files are placed in folders added
to gitignore. ftp-config.toml file is used to maintain list of data files and 
their locations both at project folder and FTP. This is default name, but other
\*.toml files can be used to split file index into separate parts. Files can
be compressed.

## Installation

`pip install ftp-loader`

## Usage

`ftp-loader -h`

   Shows help.

`ftp-loader [--overwrite] [ftp-config.toml]`

   Downloads and extracts data from FTP server. Index file name is optional.
   Default index file - ftp-config.toml.

`ftp-loader --upload [--overwrite] [ftp-config.toml]`

   Compresses and uploads data to FTP server. Index file name is optional. 
   Default index file - ftp-config.toml.

`--overwrite` Option instructs to overwrite existing files.

`--check FTP_URL` Checks user's initial path at ftp server.

`--base-path BASE_PATH` Specifies initial path at ftp. 


## Configuration

When user logs in its path can be different from the path to FTP root. In this case
path to FTP's root must be specified. This can be done in two ways.

1. By specifying --base-path parameter in command line.

2. By setting base path in the configuration file. The configuration file must have
   name `.ftp-loader-config.json` located at the user's home directory. 
   It must contain "hosts" key with a dictionary of hosts and corresponding paths.
   For example:
   {
       "hosts": {
           "server.ftp.ru": "/home/path1"
       }
   }

## Index file format

Index file must contain the following parameters:


1. FTP server URL.

    `url = "server.ftp.ru"`

2. Path to project's folder at FTP. For now only Unix-style is supported.

    `path = "/projects/test-data"`

3. List of files to be transferred. It is a list of file groups. Each group
   contain 3 or 4 parameters:
   ```
   [[files]]
   dst = "work"    # Destination folder name.
   src = "storage" # Source folder name relative to 'path'.
   arch = "bz2"    # Optional. Archive type. Supported archive formats:
                   # gz, bz2
   names = [       # list of file names.
       file1.txt,
       file2.csv
   ]
   ```

   Every group of files starts with `[[files]]` header. The number of groups 
   is arbitrary.

Example of index file can be found in tests folder - ftp-config.toml.
dsp-basicalgorithms 0.123
Basic Dsp algorithms and Filter Design
Requires Python: >=3.6

Package consists of several basic dsp algorithms implemented such as linear convolution,
circular convolution, Discret fourier transform, Auto-Correlation, Cross-Correlation, Fir filter, IIR 
filter design.The package helps students to conduct DSP Lab(18ECL57) programs pertaining to 
VTU 2018-CBCS scheme with ease.

Change Log
=============

0.123(20/8/2021)

=============
- Fourth Release
itertypes 1.6.1
A small library used to obtain types for various builtin iterators.

# IterTypes Library

[![Code Style: Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Imports: isort](https://user-images.githubusercontent.com/6032823/111363465-600fe880-8690-11eb-8377-ec1d4d5ff981.png)](https://github.com/PyCQA/isort)
[![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](http://makeapullrequest.com)

This library has some useful types and functions used to get types of iterables.
Whilst iterable types were purposely avoided by the types library, iterables offer
unique types which could sometimes be useful to obtain.

### Getting started

Start by importing the module:

```py
import itertypes
```

There are various functions which follow the naming convention `is[type]iterator`.

```py
itertypes.isstringiterator(iter("string"))
>>> True

dictionary = {1: 2, 3: 4}
iteration = iter(dictionary.items())
itertypes.isdictitemiterator(iteration)
>>> True
```

There's also the `itertypes.isiterator` function where it checks if the given
object is iterable or not.

```py
my_variable = 5
itertypes.isiterable(my_variable)
>>> False

my_variable = ['a', 'b', 'c', 'd']
all([itertypes.isiterable(my_variable), itertypes.islistiterator(iter(my_variable))])
>>> True
```

Finally, there's various types which resolve to iterable types.
These types can be used with isinstance, or with the equality operator
and the type function.

```py
byte = bytearray()
isinstance(iter(byte), itertypes.BytearrayIteratorType)
>>> True

iterable = iter({1: 2, 3: 4}.values())
isinstance(iterable, itertypes.DictValueIteratorType)
>>> True
```

### Installation

Install through pip.

```sh
python -m pip install itertypes
```