Saravanan666/pypi-org huggingface dataset:
Package: increc
FEUP-DISSThis repository hosts theSoftware library on stream based recommender systems. This is part of my thesis dissertation done at
theFaculty of Engineering of the University of Porto.General OverviewContentsThis software library contains code regarding the implementation of recommendation systems on online platforms. It implements some algorithms, test metrics and data structures, so that it can process incoming information, denoted as a stream of ratings. Each rating can beimplicitorexplicitand is given from an user to an item. Explicit ratings are direct evaluations given by users, for example on a 1-10 scale. Implicit ratings can be interpreted as actions users took on items(for example a page click) which can be interpreted as the userlikingthat specific item. Each rating is atuple:(user_id, item_id, rating). For implicit feedback the tuple becomes:(user_id, item_id)Current implemented algorithms:Explicit User-Based Collaborative FilteringExplicit User-Based Clustering Collaborative FilteringImplicit User-Based Collaborative FilteringImplicit User-Based Clustering Collaborative FilteringImplicit Locality-Sensitive-Hashing Item-Based Collaborative FilteringImplicit Locality-Sensitive-Hashing User-Based Collaborative FilteringImplicit Matrix FactorizationExplicit Matrix Factorization with matrix preprocessingExplicit Matrix Factorization without matrix preprocessingImplicit Item-Based Collaborative FilteringImplicit Item-Based Clustering Collaborative FilteringInstallCurrently the library is deployed onPypi.pip install increcDependenciesFor development purposes:Python3.8Pipenvis required to run this on a virtual environment.pip install --user pipenvpython -m pipenv lock -r > requirements.txtpipenv install -r requirements.txtRun TestsThis library usesunittestfor unit testing andflake8as its linter.pipenv run python -m unittest discover -v -p "*_test.py"pipenv run flake8Run ExamplesUsage examples are located in theexamplesfolder.pipenv run python -m examples.collaborative_filtering.neighborhood.explicit_feedback.user_based.user_based_clustering "data_set"DocumentationDocumentation is created usingSphinx.pipenv run sphinx-apidoc -f -o docs/source algorithmspipenv run sphinx-apidoc -f -o docs/source streampipenv run sphinx-apidoc -f -o docs/source data_structurespipenv run sphinx-apidoc -f -o docs/source utilspipenv run sphinx-apidoc -f -o docs/source graphicpipenv run sphinx-build -b html docs/source/ docs/buildhttps://marko50.github.io/increc-documentation
Package: incremental-backup
Incremental Backup Tool (MK 2)by Reece JonesPurposeUnlike Linux, which has awesome tools like rsync, Windows does not seem to have a good selection of free backup tools.
There is the Windows system image backup, but that does full backups only. There is also File History, but that is janky and largely opaque.Thus, I created this tool. Some of its design goals are:free, open sourceas simple as possible (no installation, no GUI, no fluff)robustfastefficienttransparent backup formatThis project is a successor to my initial attempts at an incremental backup tool for Windows, availablehere.Please seeChangesFromOriginal.mdfor details.If you have used the original incremental backup tool, please note that this version isNOT backwards compatiblewith the original.DisclaimerThis application is intended for low-risk personal use.
I have genuinely tried to make it as robust as possible, but if you use this software and lose all your data as a result, that's not my responsibility.RequirementsGeneral usage:Windows or Linux systemPython 3.9 or newerDevelopment:Pytest (any recent version should do)Application StructureImportant files and directories:incremental_backup/- The Python package.backup/- High-level backup functionality.cli/- Command line interface functionality (see also theUsagesection).meta/- Functionality related to backup metadata and structure.__main__.py- Entrypoint for using the command line interface via the package name.restore.py- Backup restoration functionality.test/- Test code. Each directory/file corresponds to the module inincremental_backup/it tests.Theincremental_backupPython package contains all application functionality and can be easily used in a library-like manner.
Additionally, this package doubles as the application entrypoint.UsageThe Python package is executable via a command line interface.
The interface uses multiple "commands" for different functionality.
Usage is as follows:python3 -m incremental_backup <command> <command_args>(You may have to adjust the Python command based on your system configuration.)Commands:backup- Creates a new backup. SeeBackupUsage.mdfor details.restore- Restores files from backups. SeeRestoreUsage.mdfor details.To start using this application, you probably want to have a look atBackupUsage.md.Program Exit Codes0 - The operation completed successfully, possibly with some warnings (i.e. nonfatal errors).1 - The command line arguments are invalid.2 - The operation could not be completed due to a runtime error (typically would be a file I/O error).-1 - The operation was aborted due to a programmer error - sorry in advance.Running TestsWith your working directory as the project root directory:python3 -m pytestThis runs a suite of unit and integration tests.
Package: incremental-convex-hull
IncrementalConvexHullIncremental Convex Hull Visualization for CSC 591, Spring 2021Starting ResourcesRead ourdocumentationIn-depth walkthroughoutlining how to use the GUI along with some interesting examplesDevelopmentWe recommend working in a virtual environment to maintain consistency across developers' machines.To set things up, run the following in the root project directory:$ python -m venv --prompt IncConvexHull --upgrade-deps venv

$ source ./venv/bin/activate      # or venv\Scripts\activate.bat in Windows cmd
                                  # or venv\Scripts\Activate.ps1 in PowerShell

$ pip install -r requirements.txt

[Development happens here]

$ deactivate                      # When you're done workingIf you ever add/change dependencies during development (e.g. runningpip installorpip upgradewithin the virtual environment), be sure to runpip freeze > requirements.txtand commit those changes to the repository.Incremental Convex Hull Concepts and BackgroundsThis interactive visualization tool will plot the points of aconvex polygonwhile incrementally growing theconvex hullas points are added. Additionally, this tool will maintain a validtraingulationof the plotted polygon. The polygons are represented using a graph data structure with nodes and edges.Convex PolygonsThe formal definition of convex polygon is a shape in which no interior angle is greater than 180 degrees. The simplest form of a convex polygon is a triangle. You can think of this visually as a shape with no "dents" in it, or edges that protrude inside the main cavity of the shape.TriangulationsEvery convex polygon can be broken down into smaller triangles, the simplest form of a convex polygon. This process of dividing a polygon into triangles is called triangulation. There are multiple ways the triangulate a shape. Our visualization supports multiple triangulations. Upon clicking aninternaledge in the polygon, the edge will then flip, producing another valid triangulation.Convex HullsA convex hull is the outtermost boundary in a set of points that encompasses all other points. This visualization tool only supports convex polygons with no colinear points. The following are properties of convex polygons:The following are properties of convex hulls:All points within a set are encompassed by the convex hullA tangent line can be drawn for each point on the convex hull such that all other points are on one side of the tangent line
Package: incremental-counter
incremental-counterIncremental Counter>>> from incremental_counter import Counter
>>> c = Counter("/tmp/counter.txt")
>>> c.current()
0
>>> c.inc()
1
>>> c.inc()
2
>>> c.reset()
0
>>> c.set(3)
3
>>> c.dec()
2
>>> c.dec()
1
>>> c.dec()
0
>>> c.dec()
0
>>> c.dec()
0history0.1.1  2018.11.03  first version0.1.3  2018.11.07  remove redundant class
Package: incremental-module-loader
Incremental Module LoaderProposes a injection pattern for your modules. Each module is simply a callable which takes other named modules as arguments. It is very simple with less than 40 statements of code and allows a great deal of flexibility while still removing frequent boilerplate we had to write on each of our projects.This module is used by our SpinHub App (https://www.spinhub.ca) which is currently in development. It is the main building block of our module/service based architecture.Use-Case 1: Modularize a flask appYou have an auth service, a database service and an blueprint creator function. How do you hook all of these together while keeping good separation of concerns and allowing injection of mocked services ? Let's see:fromincremental_module_loaderimportIncrementalModuleLoaderfromflaskimportrequest,jsonifyclassRequestParsingModule(object):defget_authorization_header(self):returnrequest.headers.get('Authorization',None)classMyAuthModule(object):def__init__(self,config,request_parser):self.url=config['AUTH_URL']self.request_parser=request_parserdefget_user_id_from_token(self):header=self.request_parser.get_authorization_header()pass# Extract user id from header token...classMyDatabaseModule(object):def__init__(self,config,auth):self.db_uri=config['SQLALCHEMY_DATABASE_URI']self.auth=authdefget_user(self):user_id=self.auth.get_user_id_from_token()pass# Retrieve user data from database...# Note the name of the arguments here:defroute_app(app,config,database):@app.route('/userinfo')defuserinfo():# This triggers the auth verification from the header extracted from the request parseruser=database.get_user()returnjsonify(user.dump())# ...defcreate_app():app=# (...) Standard app creation with config loadingmodule_loader=IncrementalModuleLoader()# First init the modules with already created objects:module_loader.update(app=app,config=app.config)# Then load in order ("incrementally")# Make sure to specify a CALLABLE object (function or class)# The module_loader will call the parameter with the modules it is asking as parameters.module_loader.load(request_parser=RequestParsingModule)module_loader.load(auth=MyAuthModule)module_loader.load(database=MyDatabaseModule)# Can be loaded anonymously, returns nothing.module_loader.load(route_app)# There you have it !CreatorsCreated by Tack Verification, a company dedicated to reducing operational costs related to hardware systems verification.https://www.tackv.ca
Package: incremental-progress
Incremental ProgressThis project is intended to be a tool for showing the incremental changes necessary to get something working.
Incremental Progress takes a copy of the source file and resulting test output for simple projects.ConfigurationTo configure Incremental Progress, create a config file in the root of your project.An example can be found in./example/config.iniOverall the setup is simple.[DEFAULT]
test_runner = pipenv run pytest
monitored_path = ./
pytest_to_markdown = True
storage_path = ./step-by-step/

[PROGRESS]
monitored_files = ['./incremental/processor.py', './setup.py', './incremental/cli.py']Wheremonitored_filesis the path from root to the file you are editing and
wheretest_runneris the command to run that executes your tests.Use of pytest-mdPytest-mdis a package that will write test outputs to an MD file.This configuration option allows for easy to read results that have the same timestamp as the incremental file.If this option is not enabled, the results will be written to a file as captured stdout and stderr.Historical Information gatheringIncremental Progress will capture a copy of thesourcefile and a snapshot of the results oftest_runnerin a temp directory.This will allow for viewing of the steps you have made during your progress towards functional code.How to capture your incremental progressInstall Incremental Progresspip install incremental-progressAdd configuration file. See the configuration sectionstart Incremental Progress:incremental-progressIncremental Progress will run till killed. This is a lightweight process as it uses watches for IO interaction and not
direct monitoring.RendersCurrent:Saves copies of the source file to a directory timestamped.Saves copies of the results oftest_runnerto a directory timestamped.Future:Turn the code into syntax highlighted frames for a gif.Turn the results of the test runner into highlighted frames for a gif.Do a left / right with code and tests results as a gif.Monitor all files in a path. Complications on this cause recursion.ImprovementsUse custom class ofDefaultDirWatcherto watch for all directoriesexceptfor thestorage_path
Package: incremental-tasks
Incremental tasksThis is a modular and extendable benchmark of progressively more difficult AI tasks to measure learning speed of ML systems.This repository contains the code to generate the incremental task dataset used
in[1].InstallationThis package can also be used as a library. Just install it from PyPI (ideally
in a virtual env if you don't want the CLI command to pollute your path).pipinstallincremental_tasksThis installs the library as well as an executablegenerate_tasks_cliTask generationThe commandgenerate_tasks_clican be used to directly generate sequences from
the command line. They are printed to stdout and can be saved to a file to
quickly create a dataset.Interactive task solvingA user can try the tasks by himself by runninggenerate_tasks_cli. This will
start an interactive session that will show random examples from the tasks of
the benchmarks, starting from the easiest.Once a task is solved, it switches to a new harder one.An example interactive session:$ generate_tasks_cli  --interactive

======================================================================
0 1 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1{?} {?} {?} {?} {?}Type you answers (space separated) 0 0 0 1 1
OK!
0 1 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 1 10 0 0 1 1======================================================================
1 0 0 0 1 0 0 0{?} {?} {?} {?} {?}Type you answers (space separated) 0 1 1 1 0
Wrong! right answer was:
1 0 0 0 1 0 0 01 0 0 0 1In[1]the human evaluation score were computed using this interactive
game with the extra flag--human-evalwhich maps every token to a random one
so the player doesn't have any prior knowledge about the text and needs to do
pattern matching like a neural network would.LibraryYou can use the library in your own code to generate the data on the fly:fromincremental_tasksimportElementaryLanguageWithWorldDeftask=ElementaryLanguageWithWorldDef()To generate a single sentence from the task usegenerate_single:print(task.generate_single())# This will print (['I', 'DO', 'NOT', 'SMELL', 'PETER', '.', 'DO', 'I', 'SMELL', 'PETER', '?', 'NO'], [11])To generatenunique sequences (will be less thannif there aren't enough
available unique sequences):task.generate_tasks(max_n_seq=n)A task can also create a generator that will yield an endless stream of
sequences (not necessarily unique):task.generate_tasks_generator(max_n_seq=None)References[1] Cisneros, H., Mikolov, T., & Sivic, J. (2022).
Benchmarking Learning Efficiency in Deep Reservoir Computing. 1st Conference on
Lifelong Learning Agents, Montreal, Canada.
Package: incubig-raven
#raven documentation
This module is used to send secured communication to incubig clients.The function takes following inputs[Optional][credentials] - Credentials in a .env file @ root directory[Mandatory][email_content] - A json object containing email subject, body and corresponding HTML[Optional][attachment] - A JSON object ({"data":file,"name":name,"type":type})[Mandatory][email_recipients] - A JSON object ({"to":[{"email":"example@example.com"},"display_name":"Display Name"],"cc":[{"email":"example@example.com"},"display_name":"Display Name"]."bcc":[{"email":"example@example.com"},"display_name":"Display Name"]})
Package: incuna-mail
Incuna MailPythonic utility for sending template based emails with Django.InstallationInstall the package:pip install incuna_mailUsageImport thesendfunction and call it:fromincuna_mailimportsendsend(to='foo@example.com',subject='Example email',template_name='plaintext_email.txt',)Supportsccandbcc...send(to='foo@example.com',cc='bar@example.com',bcc='baz@example.com',...)... lists of recipients...send(to=['foo@example.com','bar@example.com'],cc=['spam@example.com','eggs@example.com'],...)... multi-part emails...send(...template_name='plaintext_email.txt',html_template_name='html_email.html',)... template context...send(...context={'user':user},)... template lists...send(...# Uses the first template found.template_name=['might-exist.html','will-exist.html'],)... reply-to addresses...send(...reply_to=['another@example.com'],)... and custom email headers:send(...headers={'Extra-Header':'This will appear among the email headers'})The email sender can be set globally withsettings.DEFAULT_FROM_EMAIL, and will default tosettings.SERVER_EMAIL. It can be explicitly set on each call, if required:send(...sender='eggy-mcspambot@example.com',)
Package: incuna-pagination
#incuna-pagination[![Build Status](https://magnum.travis-ci.com/incuna/incuna-pagination.svg?token=9QKsFUYHUxekS7Q4cLHs&branch=master)](https://travis-ci.org/incuna/incuna-pagination)Utilities for paginated views.
- Provides a template tag that allows you to generate URLs with modified querystrings.
- Provides an include template that displays a nice pagination menu.## Installationincuna-paginationis on PyPI, so you can install it withpip install incuna-pagination.  Addpaginationto yourINSTALLED_APPS.## Usage{% include “includes/_pagination.html” %}will add the pagination display to a Django template.
Package: incuna-storages
A collection of django storage backends primarily used to set the location of files in the remote backend.InstallationUsing your favourite package manager:pip install incuna_storagesAdd to yourINSTALLED_APPS:...
'incuna_storages',
...UsageSet your storage backend to one of the included classes:DEFAULT_FILE_STORAGE = 'incuna_storages.backends.S3MediaStorage'
STATICFILES_STORAGE = 'incuna_storages.backends.S3StaticStorage'DependenciesThe included classes are built on top of existing packages. No assumptions have been made on which classes you’ll be using so nothing has been added torequired_packages.Since you’ll probably need other bits from the packages anyway it’s been left up to you, the intrepid developer, to deal with the dependencies yourself.
Package: incursion
Incursion: InfluxDB for Developers==================================.. image:: https://badge.fury.io/py/incursion.png:target: http://badge.fury.io/py/incursion.. image:: https://pypip.in/d/incursion/badge.png:target: https://crate.io/packages/incursion/.. image:: https://travis-ci.org/voidfiles/incursion.png:target: https://travis-ci.org/voidfiles/incursionIncursion is an MIT Licensed InfluxDB client, written in Python, for developers.The existing InfluxDB python client is great. This client is built onthat but many python developers have come to expect a programmaticmethod for building queries on top of a raw unstructured query interface.Incursion was built to bring a new pattern to your InfluxDB Queries... code-block:: pycon>>> import incursion as indb>>> q = indb.q('page_views')>>> q = q.columns(indb.count(indb.distinct('author_id')), 'author_id')>>> q = q.group_by(indb.time('1h'))>>> q = q.where(category__matches=indb.regex('/(10|11)/'))>>> from, to = (datetime(2014, 10, 20), datetime(2014, 10, 21))>>> q = q.where(time__gt=from, time__lt=to)>>> q = q.fill(0)>>> q = q.limit(None)>>> resp = indb.get_result(q)>>> assert resp['page_views']>>> print '%(14)s %(6)s %(2)s' % ('time', 'count', 'id')>>> for row in resp['page_views']:>>>   print '%(-14)s %(-6)s %(-2)s' % (row.time, row.count, row.author_id)time          count id1413908730239 10    11413908730239 8     2...Features--------- Query Builder Pattern- Lots of tests- Safety first (all queries have a limit unless explicitly turned off)- Ready for contributors (seriously, this should be a community project)Installation------------To install Incursion, simply:.. code-block:: bash$ pip install incursionFuture Features---------------- Continuous Query Manager (fanouts and downsampling)- In-app joining fanout query results to source series resultsContribute----------#. Fork `the repository`_ on GitHub to start making your changes to the **master** branch (or branch off of it).#. Write a test which shows that the bug was fixed or that the feature works as expected.#. Send a pull request :) Make sure to add yourself to AUTHORS_... _`the repository`: http://github.com/voidfiles/incursion.. _AUTHORS: https://github.com/voidfiles/incursion/blob/master/AUTHORS.rst.. :changelog:Release History---------------0.3.1 (2014-10-24)++++++++++++++++++* Added py34 compatability0.3.0 (2014-10-24)++++++++++++++++++* Added continuous query manager* Added end-to-end tests for some influxdb operations* Added tests to continuous query manager* Brought up compatability to InflxuDB 0.8.30.2.0 (2014-10-21)++++++++++++++++++* Initial
Package: incydr
IncydrThe Incydr SDK is a Python client for interacting with theCode42 Incydr API.It provides a thin wrapper around theRequestsHTTP library with
helper clients that model Code42 data and validate requests with the help ofPydantic.Documentation can be found athttps://developer.code42.com.Table of ContentsInstallationLicenseInstallationInstall the Incydr SDK with the following command:pip install incydrUse either of the following to install Incydr CLI extension alongside the SDK:$pipinstall'incydr[cli]'$pipinstall'incydr[all]'.For more details see theSDK Documentationand theCLI Documentation.Licenseincydris distributed under the terms of theMITlicense.
Package: incyte
Incyte: Stress Testing Made EasyIncyte is a powerful stress testing tool designed to make testing and comparing the output of your programs effortless. Whether you're a software developer, tester, or just want to ensure your code is robust, Incyte simplifies the process, saving you time and effort.FeaturesAutomatic Test Case Generation:Incyte generates random and custom test cases for your software, ensuring comprehensive testing.Compile and Run:Easily compile and run your code, tracking execution time for performance evaluation.Output Comparison:Compare the output of your code with a reference program to identify differences.Customization:Use a custom input generator or adjust build and run commands to fit your needs.InstallationYou can install Incyte via pip:pipinstallincyteUsageOnce installed, you can use Incyte from the command line. Here are the available command-line arguments:-t,--testcases: Specifies the number of test cases to generate (default: 10).-f,--file: Path to the program you want to test (required).--good-file: Path to the reference (good) program file (default: Good.cpp).--input-file: Input file for your program (default: input.txt).--output-file: Output file generated by your program (default: output.txt).--good-output-file: Reference (good) program's output file (default: output_good.txt).--custom-generator: Path to a custom input generator function (default: None).Example usage:incyte-t10-fyour_program.cppConfigurationIncyte uses a configuration file to manage custom generator functions and commands. You can modify this file located in the~/.config/incyte/config.jsondirectory.LicenseIncyte is licensed under theMIT License.Incyte: Taking the stress out of testing your software.