semvec/pypi-packages huggingface dataset:
more-transformers 0.0.11
More transformers for scikit-learn pipelines
Requires Python: >=3.6
Keywords: sklearn pipeline ml ai pandas

# more-transformers

<img src="https://upload.wikimedia.org/wikipedia/commons/a/af/Clitheroe_Castle_wind_pipes.JPG" alt="Image of Pipes" width="200"/>
My own list of "extra" transformers in scikit-learn pipelines.

# Intro

When building scikit-learn pipelines I often feel I have to do a lot of my data preparation work outside the pipeline. Moreover, many scikit-learn transformers could be more beginer friendly if they returned pandas DataFrames instead of numpy arrays.

With that in mind, this library includes a few additional transformers that are mostly thin wrappers around scikit-learn. 

For example:

    from more_transformers.preprocessing import StandardScaler
    
behaves identically to `sklearn.preprocessing.StandardScaler` but returns a pandas DataFrame with the same column names and index values as the original.

As another example

    from more_transformers.decomposition import PCA
    
is the same as `from sklearn.decomposition import PCA` but retains the index and uses column names `pca_0`, `pca_1`,...,`pca_n`.


I've also added my own few helpers, mostly under `from more_transformers.common`. For example

    from more_transformers.preprocessing import GetDummies
    
is a transformer version of pd.get_dummies. One advantage is that if the test data is transformed to have the same columns as pd.get_dummies on the training data.

Also note 

    from more_transformers.common import ColumnSelector
    
allows for very flexible selection of columns in your pipeline. For example

    ColumnSelector() # Selects all columns
    ColumnSelector(['Age','Weight','Height']) # Selects these columns
    ColumnSelector('number') # Selects all integer or float columns
    ColumnSelector(lambda x: str(x).starts_with('x_'))  # Selects columns starting with 'x_'
toto-logger-nicolasances 1.0.5
A simple logger for Toto
Requires Python: >=3.6


# Toto Logger

This library standardizes the way that toto microservices will log information.

Logs in toto have the following structure:
```
> [correlationID] - [logType] - [logLevel] - Message
```
Where:
* `correlationID`   should be always present for apis and reactive microservices and is the identifier that can be used to track the flow of data through sync and async calls
* `logType`         is the type of log. The following log types are accepted:
   * `api-in`    - **reserved** - to be used only when receiving an API call. This log type **must** be used **only once** and only **at the moment the API call is received**: it shouldn't be used for subsequent log entries. It is only used to **record the fact that an API call has been received**!
   * `api-out`   - **reserved** - to be used only when making an outbound API call.
   * `event-in`  - **reserved** - to be used only when receiving an Event. Same logic applies as for the `api-*` log type.
   * `event-out` - **reserved** - to be used only when publishing an Event. Same logic applies as for the `api-*` log type.
   * `compute`   - can be used for any log happening during the computation that results from the receiving an event or an api call.
* `logLevel`        is the level of the log. Should only be:
   * `debug`    - only used for debugging purposes
   * `info`     - used for standard info logging
   * `warn`     - used to log warnings
   * `error`    - used to log errors

## How to use it
Instantiate it:
```
from TotoLogger import TotoLogger

logger = TotoLogger()
```

Log, based on the type of log
```
logger.api_in(correlation_id, method, path);
logger.api_out(correlation_id, microservice, method, path);
logger.event_in(correlation_id, topic);
logger.event_out(correlation_id, topic);
logger.compute(correlation_id, message, log_level);

```
asteria 0.0.2
Missing AST features
Requires Python: >=3.9

# Asteria (`Al2O3`)
Missing AST features

## Features
- Repr implementation to every node (uses `astpretty` if it is available, if not fall backs to the `ast.dump`)
- AST Comparisons with other nodes
- Custom initializer with finding default values according to ASDL spec
- Shortcuts for `fix_missing_locations`, `compile` (e.g `ast.parse("2+2").compile()`)
- Unparsing shortcuts, `ast.parse("2+2").to_source()`. It uses astor if its available, if not it fallbacks to the `ast.unparse` interface.
- Parent/Child relationships to nodes
- Helpers functions for mutating tree (like `add_global` method to `Module` nodes which inserts given node at the top of body)
- Symbol table access with `get_symbol_table` method
- and many more...

## Demo
```py
>>> import ast
>>> import asteria
>>> ast.parse("2+2") == ast.parse("2+2")
True
>>> ast.parse("2+2").body[0].value
BinOp(
    left=Constant(value=2, kind=None),
    op=Add(),
    right=Constant(value=2, kind=None),
)
>>> ast.parse("print(2+2)").compile()
<code object <module> at 0x7f2602f21450, file "<ASTERIA>", line 1>
>>> eval(_)
4
>>> ast.parse("import asteria").to_source()
'import asteria'
>>> sample = ast.parse("2+2")
>>> sample.parentize()
>>> sample.body[0].value.left.parent
BinOp(
    left=Constant(value=2, kind=None),
    op=Add(),
    right=Constant(value=2, kind=None),
)
>>> sample.body[0].value.parent
Expr(
    value=BinOp(
        left=Constant(value=2, kind=None),
        op=Add(),
        right=Constant(value=2, kind=None),
    ),
)
>>> some_try = ast.parse("""\
... try:                
...     def x():        
...             print(1)
... finally: pass       
... """)
>>> some_try.parentize()
>>> some_try.body[0].body[0].body[0].value
Call(
    func=Name(id='print', ctx=Load()),
    args=[Constant(value=1, kind=None)],
    keywords=[],
)
>>> len(tuple(some_try.body[0].body[0].body[0].value.until_parented_by(ast.Try)))
3
>>> some_try.add_global(ast.parse("print('lol')").body[0])
>>> print(some_try.to_source())
print('lol')
try:

    def x():
        print(1)
finally:
    pass
```
gitdendrify 0.2.0
Transform git history between linear and structured forms
Requires Python: >=3.5

# Git dendrify

This package provides a tool to convert a git history between *linear*
and *structured* forms.  In linear form, development history is broken
down into sections and subsections by including HTML-like tag text in
the commit-message subjects.  In structured form, the sections and
subsections are represented using merge commits.

See [the project homepage](https://github.com/bennorth/git-dendrify)
for more information.
OutRemove-manav1811kumar 0.0.5
A package for removing the outliers from a dataset using inter quartile range(IQR)
Requires Python: >=3.6

This readme file is going to define some dependencies of this library before using it
This package implements the module for Outlier Removal. Make sure your data does not contain any NULL values in it. Provide the source and destination csv files while executing the code on your local machine.
Install all the dependencies.
Removal-manav1811kumar 0.0.5
A package for removing the outliers from a dataset using inter quartile range(IQR)
Requires Python: >=3.6

This readme file is going to define some dependencies of this library before using it
This package implements the module for Outlier Removal. Make sure your data does not contain any NULL values in it. Provide the source and destination csv files while executing the code on your local machine.
Install all the dependencies.