semvec/pypi-packages huggingface dataset:
Stock-Alma-Indicator 0.0.1
A small library for computing ALMA indicator for stocks
Requires Python: >=3.6

# Arnaud Legoux Moving Average (ALMA) in Python

This is a small Technical Analysis library for the calculation of Arnaud Legoux Moving Average (ALMA). It is built in Pandas and Numpy and uses [TA](https://github.com/bukosabino/ta).

## Description

The Arnaud Legoux Moving Average (ALMA) indicator is a superior moving average as compared to the Exponential Moving and Simple Moving Averages. Arnaud Legoux and Dimitrios Kouzis Loukas developed the indicator in the year 2009. The objective of ALMA is to minimize the noise and produce a more reliable signal than the conventional moving averages. The indicator (ALMA) removes small price fluctuations and also enhances the trend by applying a moving average (MA) twice, once from left to right, and once from right to left.

## Key Points on ALMA Indicator

- ALMA indicator works on the principle of the Moving Average (MA), but the calculation formula is more perfect.
- The main difference in regards to conventional moving averages is its minimal lag.
- The classic EMA, SMA, SMMA and other Moving Average lines have a significant minus – signal lag.
- The MA ALMA in this regard is more perfect. In a volatile market, this tool shows very good trading results, even without the use of auxiliary filters.

The Arnaud Legoux moving average attempts to bridge the gap and thus is expected to show both responsiveness and smoothness at the same time. Generally, the Arnaud Legoux Moving Average indicator applies the moving average twice, once from left to right and the other from right from left with the process said to eliminate price lag or phase shift significantly, a problem that is common to the traditional moving averages.

Source: Read more on [Stock Maniacs](https://www.stockmaniacs.net/arnaud-legoux-moving-average-indicator/)

## How to Use

```python
# import the package
from AlmaIndicator import ALMAIndicator

# define a Pandas dataframe which should contain closing price of the stocks
df = ...

# initialize the indicator
# you only need to provide a Pandas series of the closing price of the stock
alma_indicator = ALMAIndicator(close=df['close'])
# add alma to dataframe by calling the alma function
df['alma'] = alma_indicator.alma()
```

## Sample Result

![spy - data](https://user-images.githubusercontent.com/29625844/92999031-54f8c600-f550-11ea-974c-ae96fdb8e623.png)

Note that there will be `NaN` values at the beginning of the ALMA series since there is a window of analysis which is set to 9. In other words, your dataset must at least contain 9 entries.

## Sample Figure

![spy - alma](https://user-images.githubusercontent.com/29625844/92998867-1d3d4e80-f54f-11ea-919c-dd48c8927172.png)
zen-markup-lang 0.1.0
Read and write files in Zen Markup Language.
Requires Python: >=3.6
Keywords: zml

# Introduction

Zen Markup Language is a markup language designed to store application configs. It combines the advantages of JSON, XML and YAML. 

- ZML can store any JSON object.
- ZML keeps high readlibility even with deep nested structure like XML.
- ZML has a XML-like syntax, but is as user-frendly as YAML.
- ZML doesn't rely on indentation like JSON and XML.

# Installation

Just run this command.
```
pip install zen-markup-lang
```

# Quick Start

## Syntax

The syntax of ZML is very intuitive. The follwing example demostrates basic ZML syntax.

```XML
<!zml 0.1>
<a> 114514 </a>
<b> 1919.810 </b>
<c> true </c>
<d> false </d>
<e> null </e>
<f>
    <> "hello`t" </>
    <> "world!" </>
</f>
<g> empty_obj </g>
<h>
    <i> empty_arr </i> 
</h>
```

The ZML file above is equivalent to the following JSON object:

```JSON
{
    "a": 114514,
    "b": 1919.810,
    "c": true,
    "d": false,
    "e": null,
    "f": ["hello\t", "world!"],
    "g": {},
    "h": {
        "i": []
    }
}

```

A major difference is that the escaping character in ZML is \` instead of common \ .

## Use ZML in Python

The package is named `zen_markup_lang`. You can import the package like
```Python
import zen_markup_lang as zml
```

There are four functions in the package, `load`, `loads`, `dump` and `dumps`. They are similar to the functions in Python standard library `json`.

```Python
with open('a.zml') as f:
    d = zml.load(f)
print(zml.dumps(d))
```

That's all. Enjoy! 👏
sfdnormalize 1.1.1
Discard GUI information from SFD files
Requires Python: >=3.6

# SFD Normalize

[![Build](https://github.com/alerque/sfdnormalize/actions/workflows/build.yml/badge.svg)](https://github.com/alerque/sfdnormalize/actions/workflows/build.yml)

Normalize Spline Font Database (SFD) files by discarding GUI state information making them easier to track in version control without clutter and conflicts between users.

```console
$ sfdnormalize --help

usage: sfdnormalize [-h] [--replace] [--version] [--keep KEEP]
                    [--sfd-version VERSION]
                    input_file [output_file]
https://github.com/alerque/sfdnormalize
(For authors, see AUTHORS in source distribution.)

Normalize Spline Font Database (SFD) files

positional arguments:
  input_file            Input SFD before normalization
  output_file           Path to write normalized SFD (default: None)

optional arguments:
  -h, --help            show this help message and exit
  --replace, -r         Replace in place (default: False)
  --version, -V         show program's version number and exit
  --keep KEEP, -k KEEP  Keep lines beginning with these even if they'd be
                        normally dropped. (Can provide multiple times.)
                        (default: None)
  --sfd-version VERSION, -s VERSION
                        By default, latest SFD revision known to this program
                        will be written, unless specified here (default: 3.2)
```

## History

This script started life in the DejaVu Font project written in Perl (and dedicated to the Public Domain). At some point somebody rewrote it in Python, although I was unable to find any history between the latest Perl version and the first Python version that showed up in the Libertinus Font project.