semvec/pypi-packages huggingface dataset:
ashe 0.0.8
ashe is super extension of Python.
License: MIT License
Requires Python: >=3.6

# ashe

✨ `ashe` is a super extension of Python.

## 1 Feature

1. System

   - size

2. Dict

   - merge
   - remove

3. List

   - reverse
   - max_count

4. String

   - find

5. File

   - read
   - write

6. Date

   - today
   - yesterday
   - tomorrow
   - week
   - year
   - get_interval_days
   - get_week_days
   - get_month_days

## 2 Getting Started

### installation

```shell
pip install ashe -U
```

### usage

```Python
from ashe import *

# get size
n = 1
print(size(n))
# 28

# reverse the list
l = [1, 2, 3]
print(reverse(l))
# [3, 2, 1]

# remove key and value from dict
d = {"a": 1, "b": 2}
print(remove("a", d))
# {'b': 2}

# get today and yesterday
print(today())
# 2022-10-23
print(yesterday())
# 2022-10-22
print(get_interval_days(interval=3))
# ["2022-10-21", "2022-10-22", "2022-10-23"]
```

## 3 Consistency

\- Why `reverse(list)` not `list.reverse()`?

\- Because `len(list)` not `list.len()`.

> I find built-in method named `reversed` 🤦‍.

## 4 License

[![](https://award.dovolopor.com?lt=License&rt=MIT&rbc=green)](./LICENSE)
PyMeta3-wheel 0.5.1
Pattern-matching language based on OMeta for Python 3 and 2
License: MIT License

========
PyMeta3
========

--------------------------------------------
A Pattern-Matching Language Based on Python
--------------------------------------------

This is a fork of PyMeta 0.5.0 that supports Python 2 and 3.


Installation
============

pip install PyMeta3


Summary
=======

PyMeta is an implementation of OMeta, an object-oriented pattern-matching
language developed by Alessandro Warth
(http://www.cs.ucla.edu/~awarth/ometa/). PyMeta provides a compact syntax based
on Parsing Expression Grammars (PEGs) for common lexing, parsing and
tree-transforming activities in a way that's easy to reason about for Python
programmers.


How It Works
============

PyMeta compiles a grammar to a Python class, with the rules as methods. The
rules specify parsing expressions, which consume input and return values if
they succeed in matching.

Basic syntax
~~~~~~~~~~~~~~~~

``foo ::= ....``
   Define a rule named foo.
``expr1 expr2``
   Match expr1, and then match expr2 if it succeeds, returning the value of
   expr2. Like Python's ``and``.
``expr1 | expr2``
  Try to match expr1 --- if it fails, match expr2 instead. Like Python's
  ``or``.
``expr*``
  Match expr zero or more times, returning a list of matches.
``expr+``
  Match expr one or more times, returning a list of matches.
``expr?``
  Try to match expr. Returns None if it fails to match.
``~expr``
  Fail if the next item in the input matches expr.
``<ruleName>``
  Call the rule ``ruleName``.
``'x'``
  Match the literal character 'x'.
``expr:name``
  Bind the result of expr to the local variable ``name``.
``=> pythonExpression``
  Evaluate the given Python expression and return its result.

Comments like Python comments are supported as well, starting with #
and extending to the end of the line.

Interface
=========

The starting point for defining a new grammar is
``pymeta.grammar.OMeta.makeGrammar``, which takes a grammar definition and a
dict of variable bindings for its embedded expressions and produces a Python
class. Grammars can be subclassed as usual, and makeGrammar can be called on
these classes to override rules and provide new ones. To invoke a grammar rule,
call ``grammarObject.apply()`` with its name.

Example Usage
=============

>>> from pymeta.grammar import OMeta
>>> exampleGrammar = """
ones ::= '1' '1' => 1
twos ::= '2' '2' => 2
stuff ::= (<ones> | <twos>)+
"""
>>> Example = OMeta.makeGrammar(exampleGrammar, {})
>>> g = Example("11221111")
>>> result, error = g.apply("stuff")
>>> result
[1, 2, 1, 1]