semvec/pypi-packages huggingface dataset:
lemmaturk 0.1.0
Deep Learning based high-speed Turkish Lemmatizer
Requires Python: >=3.8

# Lemmaturk: High-Speed Turkish Lemmatizer

Lemmaturk is a deep learning-based lemmatization library designed specifically for the Turkish language. Unlike traditional rule-based systems that rely on static dictionaries and strict morphological rules, Lemmaturk utilizes a Transformer-based Sequence-to-Sequence (Seq2Seq) architecture.

This approach allows the model to "generate" lemmas rather than selecting them from a list, making it highly robust against unknown words, spelling errors, and complex agglutinative structures. It is optimized for GPU inference, offering significant speed advantages for large-scale data processing.

## Features

- **Transformer Architecture:** Uses a custom Encoder-Decoder model to understand morphological context.
- **Generative Approach:** Capable of predicting roots for words not present in the training set (Out-of-Vocabulary).
- **High Performance:** Fully compatible with CUDA for GPU acceleration.
- **Robustness:** Can handle minor OCR errors and non-standard input effectively.
- **Easy Integration:** Simple Python API designed for seamless integration into NLP pipelines.

## Installation

You can install the package directly via pip:

```bash
pip install lemmaturk
```

## Usage

The library provides a simple interface through the `Lemmatizer` class. It automatically detects if a GPU is available and moves the model to the appropriate device.

### Basic Usage

```python
from lemmaturk import Lemmatizer

# Initialize the lemmatizer
# This loads the model weights and vocabulary
lem = Lemmatizer()

# Analyze a single word
word = "kitaplaştıramadıklarımızdan"
root = lem.lemmatize(word)
print(f"Word: {word} -> Lemma: {root}")
# Output: Word: kitaplaştıramadıklarımızdan -> Lemma: kitap
```

### Batch Processing Example

```python
from lemmaturk import Lemmatizer

lem = Lemmatizer()

words = [
    "gidiyorum",
    "kalemlik",
    "gözlükçü",
    "yapılandırılması",
    "bilgisayarlarımız"
]

print("-" * 30)
print(f"{'Word':<20} | {'Lemma'}")
print("-" * 30)

for w in words:
    lemma = lem.lemmatize(w)
    print(f"{w:<20} | {lemma}")
```

## Technical Details

- **Architecture:** Transformer (Seq2Seq) with Positional Encoding.
- **Embedding Dimension:** 256
- **Hidden Dimension:** 512
- **Heads:** 8
- **Layers:** 3 Encoder / 3 Decoder
- **Training Data:** Trained on a hybrid dataset consisting of academic treebanks, web-scraped literature, and OCR-digitized historical texts (approx. 500k+ samples).

## Requirements

- Python >= 3.8
- PyTorch >= 2.0.0
- NumPy

## License

This project is licensed under the MIT License.

## Citation

If you use this tool in your research, please cite:

```text
Mahmut. (2026). Lemmaturk: Deep Learning based high-speed Turkish Lemmatizer.
GitHub/PyPI Repository.
```
cogames-agents 0.0.0.10
Optional agent policies for CoGames
Requires Python: <3.13,>=3.12

# cogames-agents

Optional scripted policies for CoGames. Use them for quick baselines, play/eval smoke tests, or as teacher policies.

## Scripted policy registry

The registry at `cogames_agents.policy.scripted_registry` maps policy `short_names` to `metta://policy/...` URIs.
Scripted agents and teachers share these identifiers, so the same name works for evaluation, play, and
`TeacherConfig.policy_uri`.

To list the current names:

```
python -c "from cogames_agents.policy.scripted_registry import list_scripted_agent_names; print(list_scripted_agent_names())"
```

Common scripted policy names include:

- Baselines: `baseline`, `tiny_baseline`, `ladybug_py`
- Nim baselines: `thinky`, `race_car`, `ladybug`, `nim_random`
- CogsGuard core: `role`, `role_py`, `wombo`
- CogsGuard variants: `alignall`, `cogsguard_control`, `cogsguard_targeted`, `cogsguard_v2`
- CogsGuard roles: `miner`, `scout`, `aligner`, `scrambler`
- Teacher: `teacher`

For the full registry snapshot, see `docs/scripted-agent-registry.md`.

Role-specific policies are exposed via role names (miner/scout/aligner/scrambler). For the teacher policy, you can pass
`role_vibes` as a comma-separated list:

```
metta://policy/teacher?role_vibes=miner,scout
```

Fixed-role mixes and explicit orderings are configured via `role_py` parameters:

Examples:

```
metta://policy/role_py?role_cycle=aligner,miner,scrambler,scout
metta://policy/role_py?role_order=aligner,miner,aligner,miner,scout
```

## Recipe usage

The `recipes.experiment.scripted_agents` recipe accepts the same scripted policy names:

```
./tools/run.py recipes.experiment.scripted_agents.play agent=thinky suite=cvc_arena
./tools/run.py recipes.experiment.scripted_agents.play agent=miner suite=cogsguard
```

## Included policies

- Short names map to the fastest implementation (Nim when available, otherwise Python).
- `_nim` aliases exist when there is a Nim implementation alongside Python.
- See `docs/scripted-agent-registry.md` for the canonical short-name list.
- Teacher wrapper: `teacher` (`teacher_nim`) forces an initial role/vibe, then delegates to the Nim policy.

## Docs

- `docs/mettaboxes.md` (mettabox usage guide)
- `docs/aws-sso-on-mettabox.md` (AWS SSO login from inside mettabox containers)
yowasp-yosys 0.62.0.0.post1088
Yosys Open SYnthesis Suite
Requires Python: ~=3.9

YoWASP Yosys package
====================

This package provides [Yosys][] binaries built for [WebAssembly][]. See the [overview of the YoWASP project][yowasp] for details.

[yosys]: https://github.com/YosysHQ/yosys/
[webassembly]: https://webassembly.org/
[yowasp]: https://yowasp.github.io/


Versioning
----------

The version of this package is derived from the upstream Yosys package version in the `X.Y[.Z][+N]` format, and is comprised of five or six parts in a `X.Y.Z.N.postM[.dev]` format, where the symbols are:

1. `X`: Yosys major version
2. `Y`: Yosys minor version
3. `Z`: Yosys patch version; only present for some Yosys releases, zero if not present
4. `N`: zero for packages built from Yosys releases, `N` for packages built from unreleased Yosys snapshots; matches the `N` in the `X.Y+N` upstream version
5. `postM`: package build version; disambiguates different builds produced from the same Yosys source tree
6. `dev`: present only for packages built from unreleased Yosys snapshots; marks these packages as pre-releases

With this scheme, there is a direct correspondence between upstream versions and [PEP 440][pep440] Python package versions. Packages built from unreleased snapshots are ignored by pip by default, but can be still installed explicitly. (These packages are uploaded daily to [TestPyPI][], but only occasionally to [PyPI][].)

A different versioning scheme was used earlier, where the package build version was denoted by a `.devM` suffix. This scheme did not work well with [PEP 440 version specifiers][pep440-vs] and was retired.

[testpypi]: https://test.pypi.org/
[pypi]: https://pypi.org/
[pep440]: https://peps.python.org/pep-0440/
[pep440-vs]: https://peps.python.org/pep-0440/#version-specifiers


Configuration
-------------

See the documentation for [the Python YoWASP runtime](https://github.com/YoWASP/runtime-py#configuration).


License
-------

This package is covered by the [ISC license](LICENSE.txt), which is the same as the [Yosys license](https://github.com/YosysHQ/yosys/blob/master/COPYING).
capstone6pwndbg 6.0.0a6
Capstone disassembly engine
Requires Python: >=3.8

To install Capstone, you should run `pip install capstone`.

If you would like to build and install Capstone with just the source distribution,
just run `python -m pip install .`, considering you are in the folder with setup.py in it.

In order to use this source distribution, you will need an environment that can
compile C code. On Linux, this is usually easy, but on Windows, this involves
installing Visual Studio and using the "Developer Command Prompt" to perform the
installation. See BUILDING.md for more information.

By default, attempting to install the python bindings will trigger a build of
the capstone native core. If this is undesirable for whatever reason, for
instance, you already have a globally installed copy of libcapstone, you may
inhibit the build by setting the environment variable LIBCAPSTONE_PATH. The
exact value is not checked, just setting it will inhibit the build. During
execution, this variable may be set to the path of a directory containing a
specific version of libcapstone you would like to use.

If you don't want to build your own copy of Capstone, you can use a precompiled
binary distribution from PyPI. Saying `pip install capstone` should
automatically obtain an appropriate copy for your system. If it does not, please
open an issue at https://github.com/capstone-engine/capstone.

--------------------------------------------------------------------------------

Capstone is a disassembly framework with the target of becoming the ultimate
disasm engine for binary analysis and reversing in the security community.

Created by Nguyen Anh Quynh, then developed and maintained by a small community,
Capstone offers some unparalleled features:

- Support multiple hardware architectures: ARM, AARCH64 (ARMv8), Mips, PPC, Sparc,
  SystemZ, XCore and X86 (including X86_64).

- Having clean/simple/lightweight/intuitive architecture-neutral API.

- Provide details on disassembled instruction (called “decomposer” by others).

- Provide semantics of the disassembled instruction, such as list of implicit
  registers read & written.

- Implemented in pure C language, with lightweight wrappers for C++, C#, Go,
  Java, NodeJS, Ocaml, Python, Ruby & Vala ready (available in main code,
  or provided externally by the community).

- Native support for all popular platforms: Windows, Mac OSX, iOS, Android,
  Linux, *BSD, Solaris, etc.

- Thread-safe by design.

- Special support for embedding into firmware or OS kernel.

- High performance & suitable for malware analysis (capable of handling various
  X86 malware tricks).

- Distributed under the open source BSD license.

Further information is available at http://www.capstone-engine.org


[License]

This project is released under the BSD license. If you redistribute the binary
or source code of Capstone, please attach file LICENSE.TXT with your products.
pyrit 0.11.0
The Python Risk Identification Tool for LLMs (PyRIT) is a library used to assess the robustness of LLMs
Requires Python: <3.14,>=3.10
Keywords: llm, ai-safety, ai-security, ai-red-team, ai-red-teaming, ai-robustness, ai-robustness-testing, ai-risk-assessment

<p align="center"><img src="./doc/roakey.png" width="150"></p>

# Python Risk Identification Tool for generative AI (PyRIT)

The Python Risk Identification Tool for generative AI (PyRIT) is an open source
framework built to empower security professionals and engineers to proactively
identify risks in generative AI systems.

- Check out our [website](https://azure.github.io/PyRIT/) for more information
  about how to use, install, or contribute to PyRIT.
- Visit our [Discord server](https://discord.gg/9fMpq3tc8u) to chat with the team and community.

## Trademarks

This project may contain trademarks or logos for projects, products, or services.
Authorized use of Microsoft trademarks or logos is subject to and must follow
[Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
Use of Microsoft trademarks or logos in modified versions of this project must
not cause confusion or imply Microsoft sponsorship.
Any use of third-party trademarks or logos are subject to those third-party's
policies.

## Citing PyRIT

If you use PyRIT in your research, please cite our preprint paper as follows:

```
@misc{munoz2024pyritframeworksecurityrisk,
      title={PyRIT: A Framework for Security Risk Identification and Red Teaming in Generative AI Systems},
      author={Gary D. Lopez Munoz and Amanda J. Minnich and Roman Lutz and Richard Lundeen and Raja Sekhar Rao Dheekonda and Nina Chikanov and Bolor-Erdene Jagdagdorj and Martin Pouliot and Shiven Chawla and Whitney Maxwell and Blake Bullwinkel and Katherine Pratt and Joris de Gruyter and Charlotte Siska and Pete Bryan and Tori Westerhoff and Chang Kawaguchi and Christian Seifert and Ram Shankar Siva Kumar and Yonatan Zunger},
      year={2024},
      eprint={2410.02828},
      archivePrefix={arXiv},
      primaryClass={cs.CR},
      url={https://arxiv.org/abs/2410.02828},
}
```

Additionally, please cite the tool itself following the `CITATION.cff` file in the root of this repository.