semvec/pypi-packages huggingface dataset:
tree-sitter-kotlin 1.1.0
Kotlin grammar for tree-sitter
License: MIT
Requires Python: >=3.9
Keywords: incremental, parsing, tree-sitter, kotlin

# tree-sitter-kotlin

[![CI][ci]](https://github.com/tree-sitter-grammars/tree-sitter-kotlin/actions/workflows/ci.yml)
[![discord][discord]](https://discord.gg/w7nTvsVJhm)
[![matrix][matrix]](https://matrix.to/#/#tree-sitter-chat:matrix.org)
[![crates][crates]](https://crates.io/crates/tree-sitter-kotlin-ng)
[![npm][npm]](https://www.npmjs.com/package/@tree-sitter-grammars/tree-sitter-kotlin)
[![pypi][pypi]](https://pypi.org/project/tree-sitter-kotlin)

Kotlin grammar for [tree-sitter](https://github.com/tree-sitter/tree-sitter).

## References

- [Kotlin Grammar](https://kotlinlang.org/docs/reference/grammar.html)

[ci]: https://img.shields.io/github/actions/workflow/status/tree-sitter-grammars/tree-sitter-kotlin/ci.yml?logo=github&label=CI
[discord]: https://img.shields.io/discord/1063097320771698699?logo=discord&label=discord
[matrix]: https://img.shields.io/matrix/tree-sitter-chat%3Amatrix.org?logo=matrix&label=matrix
[npm]: https://img.shields.io/npm/v/@tree-sitter-grammars/tree-sitter-kotlin?logo=npm
[crates]: https://img.shields.io/crates/v/tree-sitter-kotlin-ng?logo=rust
[pypi]: https://img.shields.io/pypi/v/tree-sitter-kotlin?logo=pypi&logoColor=ffd242
what2-regex 0.1.2
What2 Regex
License: MIT
Requires Python: >=3.13

# What2 RegEx

A library to help composing Regular Expressions.
Designed for readability, not speed. Directly
compiling the equivalent string literal would
be faster but probably harder to read.

If you're not the author I probably don't recommend
using this, but I also don't recommend using regular
expressions so needs must.

Class names are intentionally shorthand so they're
using snake case function-like names to improve
readability.

## Examples

A regular expression to match a file protocol
could be

```
protocol = r"(git\+)?(git|ssh|https?|file)://"
```

This is a fairly simple regular expression, but
it's not the easiest thing to read. Using this
library instead you can write

```python
from what2_regex import w2

protocol = w2.seq(
    w2.cg(
        "git",
        w2.ch.esc("+"),
    ).optional,
    w2.or_cg(
        "git",
        "ssh",
        w2.seq("http", w2.ch("s").optional),
        "file",
    ),
    "://",
)
```

Which _I_ think is easier to read.

The expression can be converted to a string
or printed directly
```python
>>> print(protocol)
(git\+)?(git|ssh|https?|file)://
```
or compiled
```python
protocol.c()
```

But what about something more complex?
How about the [grapheme clustering rules](https://unicode.org/reports/tr29/#Regex_Definitions)
```python
cr_lf = w2.seq(CR, LF)
any_ctl = w2.ch_set(CR, LF, Control)
non_ctl = ~any_ctl

hangul_inner = w2.seq(
    w2.ch(L).repeat,
    w2.or_g(
        w2.ch(V).req_repeat,
        w2.seq(LV, w2.ch(V).repeat),
        LVT,
    ),
    w2.ch(T).repeat,
)

hangul = w2.or_seq(
    hangul_inner,
    w2.ch(L).req_repeat,
    w2.ch(T).req_repeat,
)

ri_ri = w2.seq(Regional_Indicator, Regional_Indicator)
xpicto = w2.seq(
    Extended_Pictographic,
    w2.g(
        w2.ch(Extend).repeat,
        ZWJ,
        Extended_Pictographic,
    ).repeat,
)

incb = w2.seq(
    InCB_Consonant,
    w2.g(
        w2.ch_set(
            Extend,
            ZWJ,
        ).repeat,
        InCB_Linker,
        w2.ch_set(
            Extend,
            InCB_Linker,
            ZWJ,
        ).repeat,
        InCB_Consonant,
    ).req_repeat,
)

pre_core = w2.ch(Prepend)
core = w2.or_g(
    hangul,
    ri_ri,
    xpicto,
    incb,
    non_ctl,
)

post_core = w2.ch_set(
    Extend,
    ZWJ,
    SpacingMark,
    InCB_Linker,
)

op_egc_re = w2.or_seq(
    cr_lf,
    any_ctl,
    w2.seq(
        pre_core.repeat,
        core,
        post_core.repeat,
    ),
)
```

Swapping single characters a-q for each character class, this is:
```
ab|[abc]|i*(?:d*(?:e+|fe*|h)g*|d+|ll|k(?:n*pk)*|j(?:[nqp]*?q[nqp]*j)*|[^abc])[npoq]*
```
The above regex is borderline incomprehensible,
and [why I wrote this](https://pypi.org/project/what2-grapheme).
mypassmaker 1.4
Generate and safty check secure password
License: MIT
Requires Python: >=3.6

# MyPassMaker

**MyPassMaker** is a Python package designed to help you generate strong passwords and assess their safety.

[![Downloads](https://pepy.tech/badge/mypassmaker)](https://pepy.tech/project/mypassmaker)  
[![GitHub stars](https://img.shields.io/github/stars/edrisranjbar/mypassmaker?style=social)](https://github.com/edrisranjbar/mypassmaker/stargazers)

---

## Features
- Generate strong, secure passwords.
- Lightweight and easy to use.
- Test your password's safety level.
---

## Installation

Install the package via pip:

```bash
pip install mypassmaker
```

## How to Use
Generate a secure password of a specified length:

```python
from mypassmaker import Password

# Generate a 10-character password
my_password = Password.generate(length=10)
print(my_password)
```

### Checking Password Safety
The check_safety() method evaluates the safety of a password based on various criteria and returns a score between 0 and 10. The following criteria are checked:

- Length (>= 8)
- Not in the passlist (stored in passlist.txt)
- Contains special characters
- Contains both uppercase and lowercase letters
- Contains numbers (and not a number-only password)

```python
from mypassmaker import Password

password = "A1!strongPass"
safety_score = Password.check_safety(password)

print(f"Password Safety Score: {safety_score}/10")
```

### Example Scoring
- 10: Perfect password with length, complexity, and variety.
- 5: A password that meets some but not all safety criteria.
- 0: A weak password that fails several checks.

## How to Contribute
We appreciate your interest in contributing to MyPassMaker! Here's how you can help:

1. Fork the repository.
2. Make your changes or add new features.
3. Write tests to ensure your changes work as expected.
4. Submit a Pull Request (PR) with a description of your changes.

We’ll review your PR and merge it if it aligns with the project goals.

## Contact Us

We’d love to hear from you! Whether you have feedback, suggestions, or questions, feel free to reach out:

- **Email**: [edris.qeshm2@gmail.com](mailto:edris.qeshm2@gmail.com)  
- **Website**: [www.edrisranjbar.ir](http://www.edrisranjbar.ir)  
- **LinkedIn**: [Edris Ranjbar](https://www.linkedin.com/in/edris-ranjbar/)  
- **GitHub**: [MyPassMaker Repository](https://github.com/edrisranjbar/mypassmaker)

Stay connected and help us make **MyPassMaker** even better!
lighting_filters 0.1.1
A collection of data relating to lighting color filters
License: MIT
Requires Python: <4.0,>=3.9

# color-filter-sds
A collection of spectral distribution (SD) datasets for lighting color filters. 

I couldn't find a easy-to-use dataset of filters, so I compiled one myself!
For now, the dataset exists in `data/filters.json`, but I plan to eventually make other ways of accessing the data such as a Python library. 

There also exists a nicer-for-humans XLSX file at `data/filters.xlsx` with the following limitations:

- No SD data, but will show if there is data available
- CIE coords are displayed as a (x, y, Y) string which is going to suck to do math on
- No formatting

For each manufacturer, there is a set of 'raw' data in `generators/raw` that represents anything I could pull from the sources available. 
These have some more specialty measurements such as stops and mired shift that only exist for certain filters and as such don't show up in the main dataset. 
The raw data is not as uniformly manicured as the main dataset, so some additional poking around may be needed. 
These raw datasets are what the main dataset is derived from, so the data should agree with each other. 

# Sources
All filter data is owned by their respective companies, I did not measure or characterize any filter myself. 
All data here is publicly available, provided by the manufacturer to the end user. 
For more granular data or for commercial licensing, please contact the manufacturer. 
I do not work for nor am affiliated with any filter manufacturer, so please don't ask me about it!

## Apollo
The Apollo data is pulled from a set of swatchbook PDFs kindly provided to me by Apollo -- this repo does not contain these PDFs, but the parsing code is available. 
If any discrepancies are noticed, I can manually compare and provide the swatchbook pages if needed. 

The Apollo RGB values are pulled from an archived version of their [Gel Converter tool](https://web.archive.org/web/20220818010004/https://www.apollodesign.net/gel-color-filter-converter).

Apollo no longer manufactures gel as of 2020ish, but old stock may still be floating around. 
And besides, it'd be a shame to lose the delightful color names.

## Lee
The Lee data is scraped directly from the [Lee Filters](https://leefilters.com/) website. 

## Rosco
The existing Rosco data is scraped from [Rosco myColor](https://us.rosco.com/en/mycolor).

# Future Work
- Finish Rosco dataset: the spectral distribution values exist in PDF form but that's hard to parse. 
- Create Python module that integrates with the `colour-science` module
- Try graphical curve fitting to get a smart-extrapolation of SD graphs
- Clean up XLSX export
npc_shields 0.1.14
Tools for Neuropixels probe insertion: providing suggested targets, recording actual insertions, storing notes.
License: MIT
Requires Python: >=3.9

# npc_shields

[![PyPI](https://img.shields.io/pypi/v/npc-shields.svg?label=PyPI&color=blue)](https://pypi.org/project/npc-shields/)
[![Python version](https://img.shields.io/pypi/pyversions/npc-shields)](https://pypi.org/project/npc-shields/)

[![Coverage](https://img.shields.io/codecov/c/github/alleninstitute/npc_shields?logo=codecov)](https://app.codecov.io/github/AllenInstitute/npc_shields)
[![CI/CD](https://img.shields.io/github/actions/workflow/status/alleninstitute/npc_shields/publish.yml?label=CI/CD&logo=github)](https://github.com/alleninstitute/npc_shields/actions/workflows/publish.yml)
[![GitHub issues](https://img.shields.io/github/issues/alleninstitute/npc_shields?logo=github)](https://github.com/alleninstitute/npc_shields/issues)

Tools for Neuropixels probe insertion into SHIELD implants: providing suggested targets, recording actual insertions, storing notes.

## creating new implant drawings
### export 2D view of 3D model
- get a .sldpart CAD model from MPE
- open in Solidworks
- rotate the view to face the top of the implant, matching the view from the rig scope
- Save As -> .dxf
- check "current" view only

### edit 2D drawing for widget
- open a copy of one of the existing .svg drawings in Inkscape/Illustrator, to use the same page size and colors
- add the new .dxf file 
- if the lines are too thick to see any detail, change them to 1pt for now
- resize the new drawing to fill the page, like the existing drawing
- with the two drawings side by side, update the new drawing to match:
  - the outline is fragmented and needs to be joined together so a white fill can be applied
  - holes that have straight edges will need joining to be fill-able
  - circular holes should already be fill-able
  - check the CAD model for probe-letter designations (A1, A2, B1, ...)
- when finished, export as .svg
fate-scheduler 1.1.0
The operating system-level command scheduler and manager.
License: MIT
Requires Python: <4.0,>=3.8

= Fate

The operating system-level command scheduler and manager.

TODO: Objectives/justifications; features; installation and quick start-up....

== Creating tasks

Fate tasks are merely executables available through the file system. Tasks abiding by the framework's expectations may be added with a minimum of effort.

=== The contract

TODO

=== Testing

==== execute

Any executable may be invoked (with optional arguments) by the Fate `execute` command:

[source,sh]
----
fate debug execute [options] command [arguments]
----

The above generates an execution report for use in development and debugging.

Options such as `-i|--stdin` may be useful to supply measurment parameters to the executable according to the link:#_the_contract[framework's contract].

==== run

Once added to Fate configuration, executables become _tasks_. These may be invoked ad-hoc by the `run` command:

[source,sh]
----
fate debug run [options] task
----

The options and output of the `run` command are similar to those of `execute`.

Unlike with scheduled tasks, the results of tasks performed by `run` are not, by default, persisted to file. Either specify option `--record` to capture these as configured, or option `--stdout` to capture these at an arbitrary path.

== Development

=== Extending the framework

==== Set-up

Fate is implemented in https://www.python.org/[Python] and the framework's distribution is managed via https://python-poetry.org/[Poetry].

*Python v3.10* may be supplied by an operating system package manager, by https://www.python.org/[python.org], or by a utility such as https://github.com/pyenv/pyenv[pyenv]; pyenv is _recommended_ for development but _not required_.

With Python installed, *Poetry* may be installed https://python-poetry.org/docs/#installation[according to its instructions].

TIP: If you are managing your own virtual environment, _e.g._ via https://github.com/pyenv/pyenv-virtualenv[pyenv-virtualenv], then this step may be as simple as `pip install poetry`. However, this tooling is not required, and Poetry offers its own automated set-up, as well as management of virtual environments.

Finally, from the root directory of a repository clone, the framework may be installed in development mode:

[source,sh]
----
poetry install
----

NOTE: Poetry will use any existing, activated virtual environment, or create its own into which dependencies will be installed.

The `fate` command is now available for use in your development environment.

[IMPORTANT]
====
For simplicity, it will be presumed that `fate` is available on your `PATH`. However, this depends upon activation of your virtual environment.

A virtual environment under management by Poetry may be activated via sub-shell with:

[source,sh]
----
poetry shell
----

Alternatively, any command installed into Poetry's virtual environment may be executed ad-hoc via the `run` command:

[source,sh]
----
poetry run fate ...
----
====