semvec/pypi-packages huggingface dataset:
dataframe-api-compat 0.2.7
Implementation of the DataFrame Standard for pandas and Polars
Requires Python: >=3.8

[![Build Status](https://github.com/data-apis/dataframe-api-compat/workflows/tox/badge.svg)](https://github.com/data-apis/dataframe-api-compat/actions?workflow=tox)
[![Coverage](https://codecov.io/gh/MarcoGorelli/cython-lint/branch/main/graph/badge.svg)](https://codecov.io/gh/data-apis/dataframe-api-compat)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/MarcoGorelli/dataframe-api-compat/main.svg)](https://results.pre-commit.ci/latest/github/MarcoGorelli/dataframe-api-compat/main)

# Dataframe API Compat

Extremely lightweight compatibility layer between pandas, Polars, Modin and any other project which implements the [Python Dataframe API Standard](https://data-apis.org/dataframe-api/).

- ✅ No dependencies.
- ✅ Lightweight: wheel is smaller than 50 kB.
- ✅ Simple, minimal, and predictable.

Documentation, including installation instructions and tutorial, are here: https://data-apis.org/dataframe-api-compat.
vadi 0.0.7
REPL of a simple, interpreted and statically-typed programming language.
Requires Python: <4.0,>=3.10

![Banner](https://raw.githubusercontent.com/Vyogami/Vadi/main/assets/banner.png)

---

Vadi is a simple, interpreted and dynamically-typed programming language. It comes with its own tool called a REPL, which lets you try out code quickly.

The interpreter which is the part of Vadi that runs your code, uses a technique named "Recursive Descent Parsing." This technique helps the interpreter understand your high-level code by creating a data-structure called a `parse tree`. Then, the interpreter uses this parse tree to figure out what your code is asking it to do.You can check out the Vadi's [Syntax Grammar](#grammar) in BNF for more information.

## Installation

Use [pip](https://pip.pypa.io/en/stable/) or [pipx](https://github.com/pypa/pipx) to install vadi's REPL.

> [!TIP]
> The [pipx](https://github.com/pypa/pipx) package installer is strongly recommend for installing vadi on a global level to avoid conflicts.

```bash
pipx install vadi
```

OR

```bash
pip install vadi
```

Now, run the REPL.

```bash
vadi
```

## Grammar

The grammar is written in BNF(Backus Naur Form) notation.

```python

<Interpreter> ::= <binary_expression>
                | <unary_expression>
                | <statement>
                | <expression>
                | <VAR>
                | <FLT>
                | <INT>

<binary_expression> ::= <expression> "+" <expression>
                      | <expression> "-" <expression>
                      | <expression> "*" <expression>
                      | <expression> "/" <expression>
                      | <expression> "=" <expression>

<unary_expression> ::= "+" <expression>
                     | "-" <expression>

<statement> ::= "DECL" <variable> "=" <expression>

<expression> ::= <term> "+" <term>
               | <term> "-" <term>

<term> ::= <factor> "*" <factor>
         | <factor> "/" <factor>

<factor> ::= "INT"
           | "FLT"
           | "(" <expression> ")"
           | <VAR>

```

## Syntax

- Unary operations

  ```python
  +1
  -5
  ```

- Binary operations

  ```python
  56+23
  ```

- Complex arithmetic operations

  ```python
  1*2(4+5(5/6))
  ```

- Variable declarations

  ```javascript
  var int = 89;
  var float = 3.1415;
  var difference = int - 20;
  ```

- Conditionals: if-else

  > TODO: [issue#2](https://github.com/Vyogami/Vadi/issues/2)

- Conditionals: loops

  > TODO: [issue#2](https://github.com/Vyogami/Vadi/issues/2)

### Supported datatypes

- Integer
- Float

## Contributing

Issues and Pull Requests are definitely welcome! Check out [Contributing guidelines](./CONTRIBUTING.md) to get started.
Everyone who interacts with the vadi project via codebase, issue tracker, chat rooms, or otherwise is expected to follow the [Code of Conduct](https://github.com/Vyogami/.github/blob/main/CODE_OF_CONDUCT.md).

## License

This project is licensed under the MIT License. See the [LICENSE](./LICENSE).
sd212review 0.0.24
Simple Python module to tell you which unit to write review questions for SD212
Requires Python: >=3.10

# sd212review
Simple Python module to tell you which unit to write review questions for SD212

# Usage

    from sd212review import whichunit

    # you can call it with a number
    whichunit(261234) # returns 11

    # or you can call it with a string
    whichunit('m264321') # returns 2

# Build instructions

Follow [this tutorial on packaging](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
and [this quickstart for setuptools](https://setuptools.pypa.io/en/latest/userguide/quickstart.html).

Pip/conda/mamba packages needed:

    build twine

To test:

    python3 test.py

To build:

    python3 -m build

To publish on pypi (requires account setup and
[api token](https://test.pypi.org/manage/account/token/)):

    python3 -m twine upload --repository testpypi dist/*
gllogger 0.0.8
gllogger
Requires Python: >=3.6
Keywords: logger, global logger, logger hook, easy logger

```python3
# NOTE: You should import gllogger before executing any other code.
from gllogger import gL

gL.enableGlobalHandler(True)
gL.setGlobalLevel(logging.DEBUG)

...
```

```python3
# You can log into the console,
gL.getLogger(__name__).init(gL.OT_console)

# or you can pass logs into a function,
def gL_function(text):
    print(text)
gL.setFunction(gL_function)
gL.getLogger(__name__).init(gL.OT_function)

# or you can write logs to files.
import os
gL.setLogDir(os.path.join(os.getcwd(), "log", ))
gL.getLogger(__name__).init(gL.OT_logging)


# Then, use the following function anywhere to log.
gL.debugs("a", 1, True, )
gL.infos()
gL.warns()
gL.errors()

"""
[DEBUG 00:00:00 main[15].<module>] a 1 True
"""

```

```python3
# You can use 'gL(Exception)' to enable logging of complete exception tracebacks,
# and if you have 'better_exceptions' installed, the tracebacks will be even more detailed.
# $ pip install better_exceptions

try:
    def f(a, b):
        return a / b
    f(1, 0)
except ZeroDivisionError as e:
    gL.warns(gL(e))

"""
[WARNING 00:00:00 main[10].<module>] Traceback (most recent call last):
  File "/tmp/main.py", line 8, in <module>
    f(1, 0)
    └ <function f at 0x04E264A8>
  File "/tmp/main.py", line 6, in f
    return a / b
           │   └ 0
           └ 1
"""

```