semvec/pypi-packages huggingface dataset:
numfile 0.1.0
Automatically assign an increasing sequence number to file names.
Requires Python: >=3.9

# numfile

Automatically assign an increasing sequence number to file names.

## Installation

```shell
$ python -m pip install numfile
```

## Use Cases

Write data to numbered snapshot files in a given directory:

```shell
$ python -q
>>> from numfile import open_next
>>> for version in ("first", "second", "third"):
...     with open_next("/tmp/snapshot.txt") as file:
...         print(f"The {version} version.", file=file)
...

$ ls -d /tmp/* | grep snapshot
/tmp/snapshot-1.txt
/tmp/snapshot-2.txt
/tmp/snapshot-3.txt
```

Append messages to the latest log file:

```shell
$ ls -tr | grep app-error
app-error.log
app-error-2.log
app-error-3.log

$ python -q
>>> from numfile import open_latest
>>> with open_latest("app-error.log") as file: 
...     print("Oops... Something went wrong!", file=file)
...     print(file.name)
...
app-error-3.log

$ tail -n1 app-error-3.log
Oops... Something went wrong!
```

Consolidate similar files in chronological order:

```shell
$ python -q
>>> from numfile import open_all
>>> for file in open_all("/tmp/snapshot.txt"): 
...     print(file.name, file.read(), end="")
...
/tmp/snapshot-1.txt The first version.
/tmp/snapshot-2.txt The second version.
/tmp/snapshot-3.txt The third version.
```

## Development

```shell
$ git clone git@github.com:bzaczynski/numfile.git
$ cd numfile
$ pyenv local 3.9.0
$ python -m venv .venv --prompt=numfile
$ source .venv/bin/activate
$ pip install -U pip flit
$ flit install --deps=all --symlink
$ python -m pytest
```

## Releasing

### Test

Make sure there are no uncommitted or untracked files, and then bump the version:

```shell
$ bump2version minor
$ git status
$ git commit -am "Bumped version"
```

Build a new binary package:

```shell
$ rm -rf dist
$ flit build
```

Publish the binaries to the official PyPI server:

```shell
$ flit publish
```

To use the [Test PyPI](https://test.pypi.org/) server, create a file `~/.pypirc` with your username:

```
[distutils]
index-servers =
   pypi
   testpypi

[pypi]
repository = https://upload.pypi.org/legacy/
username = your-username

[testpypi]
repository = https://test.pypi.org/legacy/
username = your-username
```

Then, supply the test server using the `--repository` flag:

```shell
$ flit publish --repository testpypi
```
penkit-optimize 0.0.3
Experimental SVG optimizer using or-tools.

``penkit-optimize`` is a command-line tool for optimizing and visualizing the drawing order of SVG graphics for pen plotting. For more information, `see this post <https://bitaesthetics.com/posts/optimizing-plots-with-a-tsp-solver.html>`_.

Installation
~~~~~~~~~~~~

This package has a non-Python dependency, ``libspatialindex``. The easiest way to install it is by installing the ``rtree`` Python package via Conda::

    conda install rtree

Once this is installed, ``penkit-optimize`` can be installed via ``pip``::

    pip install penkit-optimize

Usage
~~~~~

To see CLI options::

    penkit-optimize -h
        usage: penkit-optimize [-h] [--greedy] [--noopt] [--runtime RUNTIME]
                               [--merge-paths [MERGE_PATHS]] [--vis-output VIS_OUTPUT]
                               input_file [output_file]

        positional arguments:
        input_file
        output_file

        optional arguments:
        -h, --help            show this help message and exit
        --greedy, -g          Run greedy optimization only.
        --noopt, -n           Don't run any optimization.
        --runtime RUNTIME, -t RUNTIME
                              Maximum runtime (in seconds) of optimization stage.
        --merge-paths [MERGE_PATHS], -m [MERGE_PATHS]
                              Merge paths that start/end near each other. You may
                              optionally specify a threshold distance (in document
                              units) after this parameter.
        --vis-output VIS_OUTPUT, -v VIS_OUTPUT
                              If provided, save a visualization of the path to this
                              SVG file.

Examples
~~~~~~~~

Generate optimized SVG with default options (up to 5 minute runtime), and save to ``input-optimized.svg``::

    penkit-optimize input.svg

Don't optimize anything, just visualize the transits::

    penkit-optimize input.svg -n -v noopt-vis.svg

``noopt-vis.svg``:

.. image:: examples/noopt-vis.svg

Run greedy optimization (only), save the file, and save a visualization of the result::

    penkit-optimize input.svg output.svg -g -v greedy-vis.svg

``greedy-vis.svg``:

.. image:: examples/greedy-vis.svg

Run the full optimization and write a visualization of the result::

    penkit-optimize input.svg output.svg -v opt-vis.svg

``opt-vis.svg``:

.. image:: examples/opt-vis.svg

Run the full optimization and merge paths that start/end within 1.5 units::

    penkit-optimize input.svg -m 1.5
weaklysupervised 0.0.5
Python implementation of weakly supervised learning algorithm framework
Keywords: weakly-supervised learning

Weakly Supervised Learning
==========================

Description
===========

This is a Python framework for weakly supervised learning. This package
can be used for weak supervised learning classification tasks.

Installation
============

You can install it by ``pip`` method.

.. code:: python

    pip install weaklysupervised

API
===

We have implemented following weakly-supervised learning algorithm.

-  bootstrapping

Examples
========

.. code:: python

    from examples_utils import get_data, DNN
    from sklearn import metrics
    from weaklysupervised import BootstrappingNeuralNetworkClassifier

    if __name__ == "__main__":
        X_train, X_test, y_train, y_test = get_data()
        DNN = DNN()
        clf = DNN.build_model(input_dim=30, output_dim=2)
        model = BootstrappingNeuralNetworkClassifier(clf, batch_size=128, epochs=40, bootstrapping_type="soft", 
        beta=0.95, patience=5, best_model_name="model_check_point_best_model")
        model.fit(X_train, y_train, validation_data=(X_test, y_test), )
        predict = model.predict(X_test)
        acc = metrics.accuracy_score(y_test, predict)
        print("bootstrapping accuracy", acc)

Please see ``examples`` folder for more examples.
cryptoasset-data-downloader 1.0.9
A desktop application to download historical data of desired crypto assets by connecting several different crypto-exchanges' API
Requires Python: >=3.6

# Cryptocurrency Historical Data Downloader
A desktop application to download historical data of desired crypto assets by connecting several different crypto-exchanges' API.

Historical data of crypto assets are demanded for different purposes such as investment analysis, academic research, etc. Though the data is most of the time publicly available, it is not always easy to reach it for the people who have less coding skills to connect API of crypto exchanges and download data by making several sequencing requests. Besides, crypto-exchanges mostly have different data formats that must be standardized. This application handles all these processes and makes it easier for its users.

![Application image](https://github.com/serhatci/cryptocurrency-historical-data-downloader/blob/main/application.jpg)

# Installation
Project is already uploaded in PyPI. You can download application by writing the code below in your terminal:

`pip install cryptoasset-data-downloader`
  
to execute the application, you should run below code:
 
 `cryptoasset-data-downloader`
 
# Requirements
Application works in Python version 3.6 or higher! If you would like to run the script without installing from PyPI, you need to install below dependencies: 

 ```
 pip install arrow
 pip install requests
 pip install pandas
 pip install PySimpleGUI
 ```

# How to use
Application is pretty straightforward and easy to use. You just need to select a crypto-exchange from the list and provide the name & abbreviation of the crypto asset which you would like to download historical data. It is extremely important to use exactly the same crypto asset abbreviation supported by the selected crypto exchange. By clicking 'available coins?' button, you can learn which crypto assets are being currently supported by the selected crypto exchange.

You can also select a start and end date for your historical data. It should be noted that start date of your data will dependent on the selected crypto exchange's data providing capabilities.

Historical data can be downloaded with different resolutions such as minutes,hours,days,weeks and months. However, some crypto exchanges might have limited choices for historical data resolution.
sitemap-range-fetch-wsdookadr 0.9.0
Sitemap scraper for news article selection within a certain time range
Requires Python: >=3.5

About
=====

This module provides the **SitemapRange** class and a tool to allow usage
command-line usage **sitemap_fetch.py**.

The class **SitemapRange** is meant as a generic building block for creating
news aggregating applications where the datasources are [spec-compliant](https://www.sitemaps.org/protocol.html) news websites.

There are some fault-tolerance features included to deal with some inconsistencies in sitemaps.

Install
=======

To install from pypi:

    pip install --user sitemap-range-fetch


Usage
=====

Fetching all news articles on [cnn.com](http://cnn.com) in the past 6 days, and format the result as [JSON](https://en.wikipedia.org/wiki/JSON):

    sitemap_fetch.py --site "https://cnn.com" --format json --daysago 6

More custom filtering can be done by using the **SitemapRange** class can be used

Details
=======

This module is provided as is under [MIT License](https://opensource.org/licenses/MIT).
For extensions, customizations or business inquiries you can [get in touch here](mailto:business@garage-coding.com).