semvec/pypi-packages huggingface dataset:
musx 3.0.0
An algorithmic music composition package based in part on the author's Common Music and Grace systems.
Requires Python: >=3.9

# musx
musx (pronounced *muse ex*) is a package for composing and processing symbolic music information. It contains a large set of compositional tools adapted from my Common Music and Grace systems, including support for complex pattern generation, randomness, mapping, enveloping, spectral composition, and microtonality. The musx package currently provides back ends to read and write midi files and Csound (thank you Michael Gogins!) and it is straightforward to add other backends to connect to different systems,  for example to send data to an application via portmidi, or to SuperCollider via Open Sound Control (OSC). If you are new to musx or Python, you can find installation instructions, [documentation](https://musx-admin.github.io/musx/) and demos on the [website](https://github.com/ricktaube/musx).

<hr/>
Rick Taube  

Chair, Composition/Theory<br/>
School of Music<br/>
University of Illinois Urbana-Champaign<br/>
Email: taube@illinois.edu<br/>
President, Illiac Software Inc.<br/>
https://harmonia.illiacsoftware.com/<br/>
Email: taube@illiacsoftware.com
plotly-ex 0.0.6
plotly extension
Requires Python: >=3.8

# plotly_ex
## Class/Method
```python
class make_subplots_wrapper:
    def __init__(self, col_max:int=5) -> None:
    def add_fig_sub(self, fig_sub, fig_sub_title:str=None, row:int=None, col:int=None, rowspan:int=1, colspan:int=1, secondary_y:bool=None, legendgroup:str=None) -> None:
    def build_fig(self, row_height=250, shared_xaxes=False, shared_yaxes=False, font_size_default=14, coloraxis_colorscale=None, template='plotly_dark', **kwargs) -> go.Figure:
```
sparce 0.1.14
A python package for automated feature selection
Requires Python: >=3.6

#### Statistical Processing of attributes via Recursive Cross Elimination




*SPARCE*

The sparce software is a statistical machine learning software that automates
feature seleciton in genomics data files. The software was originally outiftted
for general use in genetics, transcirptomics, methylomics and ATAC-seq data.

Installation

```{python}
conda create -n sparce pip
conda activate sparce
```

```{python}
pip install sparce
```


***HOW TO RUN***

```{python}
'''
Run inside script
'''


import sparce
import pandas as pd
from sklearn.preprocessing import OrdinalEncoder

def preprocess(file): 
  X = pd.read_csv('file')
  enc = OrdinalEncoder()
  enc.fit(X['a column in X'])
  X['a column in X'] = enc.transform(X['a column in X'])
  y = X['a column in X']
  X = X.drop('a column in X', axis = 1)
  
  return X,y

X, y = preprocess(file)

nFeatures = 5
nJobs = 10

CV = sparce.feature_selection.grade_features(X = X, y = y, nFeatures = nFeatures , nJobs = nJobs)

```


# CLI

Clone the repository and re-invoke the main function.
import args_parse into the sparce.py
Ready to run in the cli

```console

python sparce.py -x <file> -y <target> -nFeatures <int> -nJobs <int>

conda deactivate sparce

```

sparce assumptions

The data is in tidy format where (Features x samples) with a column labeled "target"
The features are continuous attributes in a classificaiton problem
The classes are mutually exclusive
nFeatures > nSamples, you are attempting to reduce the dimensionality of the problem to produce nSamples > nFeatures
RecognitionType 1.0.0
it can take STR to INT,FLOAT,BOOL,LIST

# First I want to say


I am from China.

Please email me if this article is not well written or the package has some bug.

My Mail Number : 2119244804@qq.com


# Package


This is a package. You can use

[Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)


# RecognitionType


It can take your ***STR*** to other thing, for example, you can take a str to a list.


# Class RecognitionType


First your should `from RecognitionType import RT`

Use `a_object = RT.RecognitionType()` to take a new object.


# The `everyr(content)`


Use `everyr(content)` to take ***STR*** to other thing.

For example:

```
import RT
a_object = RT.rt()
a_v = a_object.everyr('["thing","thing"]')
print(type(a_v), a_v)
```

`>>> <class 'list'> ['thing', 'thing']`

![img_1.png](img_1.png)

And:
 
```
import RT
a_object = RT.RecognitionType()
a_v = a_object.everyr('"thing"')
print(type(a_v), a_v)
```
 
`>>> <class 'str'> thing`


# Other method


`strr(content)`
`intr(content)`
`floatr(content)`
`boolr(content)`
`listr(content)`

For example:
 
```
import RT
a_object = RT.rt()
a_v = a_object.dictr('{"thing_1":1, "thing_2":"thing"}')
print(type(a_v), a_v)
```
 
`>>> <class 'dict'> {'thing_1': 1, 'thing_2': 'thing'}`


# Can't get thing


If the `everyr(codent)` or others can't get thing.

They will return `None`

For example:
 
```
import RT
a_object = RT.rt()
a_v = a_object.dictr('["thing"]')
print(type(a_v), a_v)
```
 
`>>> <class 'NoneType'> None`

Or:
 
```
import RT
a_object = RT.rt()
a_v = a_object.everyr(ddddd)
print(t]ype(a_v), a_v)
```

```
>>> RTError: Can't Return [Return None]
>>> <class 'NoneType'> None
```
 
![img.png](img.png)


# RecognitionTypeVersion


The version is v1.0

Use `rversion()` can get version.


# Update log(Future plans)


v1.0 Can take your STR to other thing
 
v1.1 `dictr` and `tupler`

v1.2 `byter`

v2.0 Use new way to rt
feature-selection-michaelSkaro 0.0.1
A python package for automated feature selection
Requires Python: >=3.6

# Feature selection for ML workflows
This python package will automate feature selection in ML projects.

In the coming weeks I will add a plethora of information describing the use of the package and the algorithms that are working under the hood.

For now we will settle for a simple Read me to get us started on 0.0.1. 

As a general description this package is intended for the use of novice users looking for general feature seleciton in an automated fashion. This will not replace your own featue analysis but can help users make a good first step eliminating redundant features and begin looking for strong signals in their feature columns. 

# TODO
[X] python3 -m pip install --upgrade build

[] python3 -m build

[] python3 -m pip install --upgrade twine

[] python3 -m twine upload --repository feature_selection dist/*
  -  You will be prompted for a username and password. For the username, use __token__. 
  
  - For the password, use the token value, including the pypi- prefix.