semvec/pypi-packages huggingface dataset:
TCSP 0.0.9
Traditional Chinese Stopwords and Punctuations Library
License: MIT
Keywords: stopwords

# Traditional Chinese Stopwords and Punctuations

This library is created specifically for Traditional Chinese stopwords and punctuations removal.

It also includes NLTK's English stopwords and numbers if you are processing a hybrid of Chinese and English text data.

# Get Started

pip install TCSP

from TCSP import read_stopwords_list

Calling the 'read_stopwords_list()' function will return the stopwords list


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

0.0.1 (Nov/26/2021)
-------------------
- First release

0.0.2 (Nov/29/2021)
-------------------
- Updated project description

0.0.3 (Nov/29/2021)
-------------------
- Updated README.md

0.0.8 (May/19/2022)
-------------------
- Fixed issue with read_stopwords_list()

0.0.9 (May/19/2022)
-------------------
- Updated change log
hax 0.3.0
Write compiled bytecode inline with standard Python syntax.
License: MIT
Keywords: bytecode

<div align=center>

HAX
===

[![latest version](https://img.shields.io/github/release-pre/brandtbucher/hax.svg?style=for-the-badge&label=latest)![latest release date](https://img.shields.io/github/release-date-pre/brandtbucher/hax.svg?style=for-the-badge&label=released)](https://github.com/brandtbucher/hax/releases)[![build status](https://img.shields.io/github/workflow/status/brandtbucher/hax/CI/master.svg?style=for-the-badge)](https://github.com/brandtbucher/hax/actions)[![issues](https://img.shields.io/github/issues-raw/brandtbucher/hax.svg?label=issues&style=for-the-badge)](https://github.com/brandtbucher/hax/issues)

<br>

</div>

<div align=justify>

HAX lets you write compiled bytecode inline with pure Python. It was originally
built for exploring new improvements to CPython's compiler and peephole
optimizer.

Installation
------------

HAX supports CPython 3.7+ on all platforms.

To install, just run:

```sh
$ pip install hax
```

Example
-------

Consider the following function; it accepts a sequence of items, and returns a
list with each item repeated twice:

```py
def doubled(items):
    out = []
    for item in items:
        out += item, item
    return out
```

For example, `doubled((0, 1, 2))` returns `[0, 0, 1, 1, 2, 2]`.

We can make this function faster by keeping `out` on the stack (instead of in a
local variable) and using the `LIST_APPEND` op to build it. HAX makes it
simple to inline these instructions:

```py
from hax import *

@hax
def doubled(items):

    BUILD_LIST(0)

    for item in items:

        LOAD_FAST("item")
        DUP_TOP()
        LIST_APPEND(3)
        LIST_APPEND(2)

    RETURN_VALUE()
```

With the help of labeled jump targets (`HAX_LABEL`), the function can be further
sped up by rewriting the for-loop in bytecode, removing _all_ temporary
variables, and operating **entirely on the stack**:

```py
from hax import *

@hax
def doubled(items):

    BUILD_LIST(0)

    LOAD_FAST("items")
    GET_ITER()
    HAX_LABEL("loop")
    FOR_ITER("return")

    DUP_TOP()
    LIST_APPEND(3)
    LIST_APPEND(2)
    JUMP_ABSOLUTE("loop")

    HAX_LABEL("return")
    RETURN_VALUE()
```

It's important to realize that the functions HAX provides (`BUILD_LIST`,
`LOAD_FAST`, ...) aren't just "emulating" their respective bytecode
instructions; the `@hax` decorator detects them, and completely recompiles
`doubled`'s code to use the _actual_ ops that we've specified here!

These performance improvements are impossible to get from CPython's compiler and
optimizer alone.

</div>
modul 0.2.0.post0
Control the exported members for your modules
License: MIT
Requires Python: >=3.7

# Modul

`/moˈduːl/`

[![Tests](https://github.com/frostming/modul/workflows/Tests/badge.svg)](https://github.com/frostming/modul/actions?query=workflow%3Aci)
[![pypi version](https://img.shields.io/pypi/v/modul.svg)](https://pypi.org/project/modul/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![pdm-managed](https://img.shields.io/badge/pdm-managed-blueviolet)](https://pdm.fming.dev)

Control the exported members for your modules

## Requirements

Modul requires Python >=3.7

## Installation

```bash
$ python -m pip install modul
```

Modul is a single-file module with less than 200 lines of code and no dependencies. It can be easily copied into your project.

## Quick start

Write a module exporting limited members:

```python
# mymodule.py
from modul import exports


@exports
def foo():
    return 42


baz = "unexported"
bar = "hello"

exports.bar = bar
```

In another module or REPL:

```python
>>> import mymodule
>>> mymodule.foo()
42
>>> mymodule.bar
"hello"
>>> mymodule.baz
AttributeError: Module test has no attribute baz
>>> mymodule.__all__
['foo', 'bar']
```

## Usage

1. Export a function with decorator:

   ```python
   @exports
   def foo():
       return 42
   ```

2. Export a variable with attribute set:

   ```python
   exports.bar = 42
   ```

   Note that to use the variable inside the module, you still need to declare a variable for it:

   ```python
   bar = 42
   exports.bar = bar
   ```

3. Export a variable with item set:

   ```python
   exports["bar"] = 42
   ```

   Besides, the `exports` object supports all APIs of `dict`:

   ```python
   exports.update({"bar": 42})
   ```

4. Export a map of (name, value) pairs:

   ```python
   exports({
       "bar": 42,
       "baz": "hello"
   })
   ```

5. You can even have conditional exports and exports from function call:

   ```python
   flag = True
   if flag:
       exports.foo = 42

   def export_bar():
       exports.bar = 42
   export_bar()
   ```

6. Alternatively, you can assign members to the `exports` attribute of the module:

   ```python
   import modul

   modul.exports = {
       "bar": 42,
       "baz": "hello"
   }
   ```

   Note that you can't use `exports = <variable>` in this case, because it will lose the reference to the API.
   And each assignment will overwrite the previous one so there can be only one assignment in your module.
yodine-data 0.4.0rc3
All the assets, entities and levels that come with Yodine (the game). Note there can be multiple games for Yodine (the engine).
License: MIT
Requires Python: >=3.5.0

# yodine_data

**A Yodine plugin by Gustavo6046**

All the assets, entities and levels that come with Yodine (the game). Note there can be multiple games for Yodine (the engine).

-----

Licensed under MIT.
Yodine 0.4.0rc3
A simple pyglet-powered 2D game engine, with simple multiplayer support.
License: MIT

######
Yodine
######

Briefly put, Yodine is a special, flexible, fun, easily extensible game, written in Python, with advanced plugin support,
that uses pyglet and an involved Entity-Component-System infrastructure.

It is easy to write plugins for Yodine. And it is easy to *feel the structure*. (Just don't let the cows do so. They're evil
monsters.)

**Notice: the game is currently in a development stage. Expect bugs and a lack of features.**



How to play
***********

In order to install the game, simply run:

..  code:: bash

    pip install yodine


Running it is quite simple, too:

..  code:: bash

    python -m yodine.launcher



Writing Plugins
===============

In order to write a plugin for Yodine, you may run the following module:

..  code:: bash

    python -m yodine.utils.plugin_init

After answering a few questions, a generous, helpful filesystem structure will be generated. The files are
heavily commented, to aid you in your quest to add to the game. Let's build a castle?



Editing Maps
============

In order to create or edit a map for Yodine, simply run:

..  code:: bash

    python -m yodine.editor my_map.save.json



Hosting Servers
===============

In order to host a server for Yodine, run the following:

..  code:: bash

    YODINE_DEDICATED=y YODINE_LISTEN=8081 python -m yodine my_map.save.json

Of course, replace the :code:`8081` in :code:`YODINE_LISTEN=8081` by the desired listen port. The standard
*should* be 8081, but since the default is not listening at all, there is unfortunately no obvious
way to tell that.

License
*******

This project and its source code are available under [the MIT license](https://opensource.org/licenses/MIT),
under the autorship of Gustavo Ramos Rehermann (:code:`rehermann6046@gmail.com`).
dataclassmodule 0.1.1
dataclass + nn.Module
License: MIT
Requires Python: >=3.10,<4.0

# DataclassModule

dataclass + nn.Module

## Usage 

```python
from dataclassmodule import DataclassModule

class ExampleModule(DataclassModule):
    x: int
    
    def __post_init__(self):
        self.layer = nn.Linear(2, 2)
```