Saravanan666/pypi-org huggingface dataset:
Package: activityio
Exercise/activity data has become a prolific resource, but applying any kind of sophisticated analyses is made difficult by the variety of file formats. Thispythonlibrary is intended to munge a number of these formats and present the data in a predictable and useable form. Moreover, the API is both closely intertwined with, and an extension of, the awesomePandas library.StabilityPlease note this package is still very much analpharelease, sobreaking changesare likely.InstallationThe package is available on PyPI:$ pip install activityioExample UsageThere is areadfunction at the top-level ofactivityiothat dispatches the appropriate reader based on file extension:>>> import activityio as aio
>>> data = aio.read('example.srm')NOTEsubstitute'example.srm'with a path to your own activity file.But you can also call sub-packages directly:>>> from activityio import srm
>>> data = srm.read('example.srm')datain the above example is a subclass of thepandas.DataFrameand provides some neat additional functionality. Most notably, certain columns are “magic” in that they return specificpandas.Seriessubclasses. These subclasses make unit-switching easy, and provide other useful methods:>>> type(data)
<class 'activityio._types.activitydata.ActivityData'>>>> data.head(5)
          temp  lap   dist  alt  cad  pwr  speed  hr
time
00:00:00  26.1    1  1.027   67    0    0  1.027  71
00:00:01  26.1    1  2.721   67    0    0  1.694  71
00:00:02  26.2    1  4.415   67    0    0  1.694  71
00:00:03  26.2    1  6.331   67    0    0  1.916  71
00:00:04  26.2    1  8.469   67    0    0  2.138  75>>> data.normpwr()
249.54104255943844>>> type(data.speed)
<class 'activityio._types.columns.Speed'>>>> data.speed.base_unit
'm/s'
>>> data.speed.kph.mean()  # use a different unit
38.485063801685477>>> data.dist.base_unit
'm'
>>> data.dist.miles[-1]
134.78580023361226>>> data.alt.base_unit
'm'
>>> data.alt.ascent.sum()
1898.0
```ButNOTEyou lose this functionality if you go changing column names>>> data = data.rename(columns={'alt': 'altitude'})
>>> type(data.altitude)
<class 'pandas.core.series.Series'>API NotesThe main package is composed of sub-packages that contain the reading logic for the file format after which they’re named. (e.g.activityio.fitis for parsing ANT/Garmin FIT files.)The ultimate logic is defined in a_readingmodule, which provides two functions:gen_recordsandread_and_format.gen_recordsis a generator function for iterating over the data-points in a file. The rows of the data table if you like. A “record” is a dictionary object.read_and_formatuses the above generator to return anActivityDataobject.read_and_formatis available at the top-level of a sub-package aliased asread; so reading in a file looks likesrm.read('path_to_file.srm').gen_recordsis imported under the same name.There are also some usefultoolsprovided in module by the same name.
Package: activitypub
This is a Python library to use withActivityPub.
ActivityPubis an API for an open, distributed, social network.InstallYou can install the development version of activitypub with:pip install git+git://github.com/dsblank/activitypubor the last packaged version with:pip install activitypubTo use with redis:pip install redis redis_collectionsOR to use with mongodb:pip install pymongoOR to use with SQLAlchemy:pip install sqlalchemyAbstractionsThis module is designed to be a generally useful ActivityPub library in
Python. It targets three different levels of use:ActivityPub object APIActivityPub database APIWebserver APIThese levels can be used independently, or together. They can best be
used together using a Manager:>>>fromactivitypub.managerimportManager>>>fromactivitypub.databaseimportListDatabase>>>db=ListDatabase()>>>manager=Manager(database=db)>>>p=manager.Person(id="alyssa")>>>p.to_dict(){'@context':'https://www.w3.org/ns/activitystreams','endpoints':{},'followers':'https://example.com/alyssa/followers','following':'https://example.com/alyssa/following','id':'https://example.com/alyssa','inbox':'https://example.com/alyssa/inbox','liked':'https://example.com/alyssa/liked','likes':'https://example.com/alyssa/likes','outbox':'https://example.com/alyssa/outbox','type':'Person','url':'https://example.com/alyssa'}>>>db.actors.insert_one(p.to_dict())>>>db.actors.find_one({"id":'https://example.com/alyssa'}){'@context':'https://www.w3.org/ns/activitystreams','endpoints':{},'followers':'https://example.com/alyssa/followers','following':'https://example.com/alyssa/following','id':'https://example.com/alyssa','inbox':'https://example.com/alyssa/inbox','liked':'https://example.com/alyssa/liked','likes':'https://example.com/alyssa/likes','outbox':'https://example.com/alyssa/outbox','type':'Person','url':'https://example.com/alyssa','_id':ObjectId('5b579aee1342a3230c18fbf7')}activitypub supports the following databases:MongoDBSQL dialects — any that that sqlalchemy supports, including:SQLite (including in-memory)FirebirdMicrosoft SQL ServerMySQLOraclePostgreSQLSybase… and many more!An in-memory, JSON-based database for testingRedisThe activitypub database API is a subset of the MongoDB.activitypub is targeting the following web frameworks:FlaskTornadoOthers can be supported. Please ask!The activitypub webservice API is based on Flask’s.
Package: activity.py
activity.pyLoad running activities, output into a neat JSON format.InstallationInstall this library usingpip:pip install activity.pyUsageImportActivityand use theload_fitandload_gpxfunction to load your activities.
You can access attributes on the activity at that point, or alternatively useas_jsonto dump your activity as a JSON object.fromactivity_pyimportActivityactivity=Activity.load_fit('fitfile.fit')print(activity.duration,activity.distance,activity.pace)DevelopmentTo contribute to this library, first checkout the code. Then create a new virtual environment:cd activity.py
python -m venv venv
source venv/bin/activateNow install the dependencies and test dependencies:pip install -e '.[test]'To run the tests:pytestUsingpipenv, this looks like:pipenv install .[test]
pipenv run pytestActivity JSONDocumentation TBC.
Package: activitysim
[![Build Status](https://travis-ci.com/ActivitySim/activitysim.svg?branch=main)](https://travis-ci.org/github/ActivitySim/activitysim)[![CoverageStatus](https://coveralls.io/repos/github/ActivitySim/activitysim/badge.svg?branch=main)](https://coveralls.io/github/ActivitySim/activitysim?branch=main)The mission of the ActivitySim project is to create and maintain advanced, open-source,
activity-based travel behavior modeling software based on best software development
practices for distribution at no charge to the public.The ActivitySim project is led by a consortium of Metropolitan Planning Organizations
(MPOs) and other transportation planning agencies, which provides technical direction
and resources to support project development. New member agencies are welcome to join
the consortium. All member agencies help make decisions about development priorities
and benefit from contributions of other agency partners.## Documentationhttps://activitysim.github.io/activitysim
Package: activitystreampython
activitystreampythonA Python 3 module for interacting with the Activity Stream Data Service API v1.To find out more about the Activity Stream Data Service API,browse the Swagger documentation.UsageInstallationpip install activitystreampythonSample usagefromactivitystreampythonimportActivityStreamAPIfromdatetimeimportdatetime,timezone,timedeltatenant="demo"# Your Activity Stream tenant (this will be the same as the Activity Stream subdomain)username="example@example.com"# The email address for your API userpassword="correct-horse-battery-staple"# The password for your API user - NB: don't store passwords in code!end_datetime=datetime.now(timezone.utc)start_datetime=end_datetime-timedelta(days=7)activity_stream=ActivityStreamAPI(tenant=tenant,username=username,password=password)# Retrieve customers# This method initialises a generator which can be iterated over to retrieve customer datacustomers=activity_stream.ticketing_data(data_type="customers",start_datetime=start_datetime,end_datetime=end_datetime,filter_type="updatedate",)forcustomerincustomers:print(customer)# Retrieve tickets# This method initialises a generator which can be iterated over to retrieve ticket datatickets=activity_stream.ticketing_data(data_type="tickets",start_datetime=start_datetime,end_datetime=end_datetime,filter_type="updatedate",)forticketintickets:print(ticket)# Retrieve marketing permissions# This method initialises a generator which can be iterated over to retrieve marketing permission datamarketing_permissions=activity_stream.marketing_data(start_datetime=start_datetime)formarketing_permissioninmarketing_permissions:print(marketing_permission)NotesWe recommend using theupdatedatefilter_typeif you are using this package to keep an external
database up-to-date with Activity Stream data. That way you can be sure that you will never miss out
on data even if historic records are backfilled in Activity Stream. For the initial import, using theeventdatefilter_typemay be more predictable in terms of data volumes for each time period.This package is not officially supported, although we do use it internally and will endeavour to
avoid breaking changes.LicenseCopyright 2023 crowdEngage LimitedLicensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
Package: activitystreams2
activitystreams2is a python library for producing Activity Streams 2.0
content. It doesn‘t have a lot of features (no extensions) but aims to be give
correct results and be easy to understand.At the moment, only supports writing activity streams.InstallingThe recommended way of manually installing activitystreams2 is via pippip3installactivitystreams2Examplesimportactivitystreams2martin=activitystreams2.Actor(id='http://www.test.example/martin')activity=activitystreams2.Create(actor=martin,summary='Martin created an image',object='http://example.org/foo.jpg',)# do this to serialize itjson_string=str(activity)CaveatsWe completely don’t support extension types at the moment.AlternativesThe only python Activity Streams 2 library I know of isactivipy. It supports extension types, but it‘s
still pre-alpha and seems to have been forgotten.Changes0.5Rename to activitystreams2Add api documentation0.4.1Document upcoming name changeDrop PBR and switch to using a package0.4Add rudimentary support for extension properties0.3Fix bug printing collections with only 1 item0.2.0Add support for ActivityPub extension0.1.0Initial version
Package: activityTasks-udacity-inventrohyder
Activity Tasks moduleAs part of the Udacity Machine learning nanodegree, creating and uploading a package
is on of the projects to carry out.The following package contains code that was part of Minerva schools at KGI algorthims
class.The package allows creation of Activities and link them with Tasks.To see an example of usage check:https://github.com/Inventrohyder/CS110/blob/master/Assignments/cs110_assignment_2/cs110_assignment_2.ipynb
Package: activity-tools
activity-toolsThis project contains building blocks that can be used to create ActivityPub applications.Project status: Experimental, work in progressDocumentationFeel free to browse the code, or read the generateddoumentation. If you prefer an example instead I have included arun.pywho runs a small sample instance.InstallInstall it fromPyPI. Versions after 1.0.0 will follow semantic versioning with amajor.minor.patchwhere breaking changes should only occur with a major version bump.pip install activity-tools
Package: activizer
ActivizerInterface for Active LearningAbout Active LearningActive learning is the process by which a learning algorithm can query a user
interactively to label data points which are close to the decision boundary formed during classificationThe primary objective of this project is to build an Interface for Active learning which
simplifies the process of chosing algorithms,query strategies and labels This eliminates the task of writing programs for each task  
The interface helps annotators of various domains to label data in an interactive manner and also provides features of saving the final model and resultsInterface for Active Learning supports Image dataset where the user can upload data in Zip format. It supports 3 classifiers and 7 query strategies.ClassifiersKNN ClassifierRandom Forest ClassifierDecision Tree ClassifierQuery StrategiesUncertainty SamplingRandom SamplingEntropy SamplingQuery By Committee(Uncertainty Sampling)Query By Committee(Vote Entropy Sampling)Query By Committee(Max Disagreement Sampling)Query By Committee(Consensus Entropy Sampling)This project is implemented with the Active Learning packagemodALHow to RunThis project requires python 3.x installed on your machineInstallationThe package can be installed using the command : pip install activizerOpen Python console and run the following commandsfrom activizer import appapp.run()Copy the url in the browserSelect the Classifier Algorithm, the Query Strategy and give the number of samples you wish to label. Then select the training / testing dataset in Zip formatFor each iteration an image will be shown and a dropdown to label that image. Below them will be shown a graph with current accuracy.After all the iterations are over, Final accuracy with graph will be shownThe user can see the images along with the labels provided by the algorithm selected during training. The trained model can be downloaded in pickle format (.pickle file) and can be used for prediction by clicking "Already have a model" on the Main Page. The user can then upload the pickle file and use the model to classify imagesThe Interface can be used for prediction by uploading the validation dataset in Zip format.The result will be shown in a table consisting of image name and label predicted by the model.
Package: actl
Introductionactl is a command line application engine for Python, it provides an utility and library for the development of modular command line applications.Features2 lines of code for themainfunctionUsesClickfor modular command line definitionsAutomatic loaded command modules «fromcommands/*.py»Installationactl is avaiable from the official Python Package Index (PIP), you can install it from the terminal:pipinstallactlHello Worldmain.pyimportactlactl.main(__name__,__file__)commands/hello.pyimportclick@click.command()defhello():print("Hello")Test the app:pythonmain.py
Package: act-neuron
Automatic Cell Tuner (act)actprovides tools for optimization-based parameter selection for biologically realistic cell models developed inNEURON. The project is inspired by theASCTlibrary.actrelies on a simulation-based optimization, i.e., for a pipelineParameters -> Black-box simulator -> Simulated datait tries to obtain parameter estimates indirectly by working with simulated data.InstallationCurrently,actcan be installed from GitHub using pip or locally with the standardpipinstallation process.pipinstallact-neurongitclonehttps://github.com/V-Marco/ACT.gitcdACT
pipinstall.UsagePrerequisitesConceptually,actrequires three components.A.hocfile which declares the cell's properties.Modfiles for this.hocfile.Target voltage data of shape (num_cur_inj, ...) to predict on OR parameters to simulate target data with.Pipelineactoperates in original and segregated modes. Original mode runs in the following steps:Generate a parameter set uniformly randomly from a (lower; upper) interval for each current injection.Simulate a voltage trace for each current injection and respective parameter set.Extract key summary features (e.g., inter-spike time), and keep parameter sets for those voltage traces which match the target voltage trace in these summary features.Repeat steps 1-3 until the specified number of current injections is matched.Train a neural network model to predict conductance values from a voltage trace using saved sets as targets.Predict conductance values by applying the trained model to the target voltage data. Take the maximum of each predicted value across all current injections.Segregated mode changes step 5 so that the model is trained on regions of a voltage trace. The regions can be specified in terms of time (X-axis) or voltage (Y-axis) bounds.Setting up a simulationSimulations' parameters are defined aspythonclasses insimulation/simulation_constants.py.Names of parameters to optimize for are defined in theparamsproperty. The names must match the hoc file. Lower and upper bounds are specified inlowsandhighsproperties.Segregated parameters and respective time/voltage bounds are specified as lists-of-lists in the respectivesegr_...properties.Running a simulationsimulation/run_simulation.pyis an example script of runningacton Pospichil's cells.simulation/analyze_res.pyis an example script which gives a summary of the model's quality.Examples (Jupyter Notebook)examples/Pospischil_sPYr/main.ipynbexample of runningacton Pospichil's cellsOn Google Colab:Pospischil_sPYrLA Type A
Package: acton
Acton is a modular Python library for active learning.Actonis a suburb in Canberra, where Australian National University is
located.DependenciesMost dependencies will be installed by pip. You will need to manually install:Python 3.4+ProtobufSetupInstall Acton usingpip3:pipinstallgit+https://github.com/chengsoonong/acton.gitThis provides access to a command-line toolactonas well as theactonPython library.Acton CLIThe command-line interface to Acton is available through theactoncommand. This takes a dataset of features and labels and simulates an
active learning experiment on that dataset.InputActon supports three formats of dataset: ASCII, pandas, and HDF5. ASCII
tables can be any file read byastropy.io.ascii.read, including many common
plain-text table formats like CSV. pandas tables are supported if dumped to a
file fromDataFrame.to_hdf. HDF5 tables are either an HDF5 file with datasets
for each feature and a dataset for labels, or an HDF5 file with one
multidimensional dataset for features and one dataset for labels.OutputActon outputs a file containing predictions for each epoch of the simulation.
These are encoded as specified inthis notebook.QuickstartYou will need a dataset. Acton currently supports ASCII tables (anything that can be read byastropy.io.ascii.read), HDF5 tables, and Pandas tables saved as HDF5.Here’s a simple classification datasetthat you can use.To run Acton to generate a passive learning curve with logistic regression:acton--dataclassification.txt--labelcol20--featurecol10--featurecol11-opassive.pb--recommenderRandomRecommender--predictorLogisticRegressionThis command uses columnscol10andcol11as features, andcol20as labels, a logistic regression predictor, and random recommendations. It outputs all predictions for test data points selected randomly from the input data topassive.pb, which can then be used to construct a plot. To output an active learning curve using uncertainty sampling, changeRandomRecommendertoUncertaintyRecommender.To show the learning curve, useacton.plot:python3-macton.plotpassive.pbLook at the directoryexamplesfor more examples.
Package: actontext
actontextThis module provides functions to load COM DLL on Windows machine, to avoid registering it in Windows registry.
You can find more about how it can be done in articles on web:Registration-Free Activation of COM Components: A Walkthrough;Create side-by-side registrationless COM manifest with VS;etc. just Google itPossibly the main use case for package could be lightweight testing of COM objects, created from built in-proc COM servers
Package: actor
A simple actor framework with dynamic parallelismFree software: GNU Lesser General Public License v2.1 or later (LGPLv2+)Installationpip install actorYou can also install the in-development version with:pip install https://github.com/yasserfarouk/actor/archive/master.zipDocumentationhttps://actor.readthedocs.io/DevelopmentTo run the all tests run:toxNote, to combine the coverage data from all the tox environments run:Windowsset PYTEST_ADDOPTS=--cov-append
toxOtherPYTEST_ADDOPTS=--cov-append toxChangelog0.0.0 (2020-06-16)First release on PyPI.
Package: actor-loader
Actor Loader - Vanilla Actors with CollisionAn automation tool for quickly putting the right Collision Actors (C-Actors, Vanilla Actors with Collision) in your mod.What is ActorLoader for?To understand this, you must first be familiar with C-Actors.C-Actors was originally a mod including every applicable actor in the game with attached collision.
These actors could be used in Ice-Spear to make landscape scenes quickly without having to worry about manually adding collision to them. A timely process that was easy to mess up.The original C-Actors mod would be required as a prerequisite in every mod using it.
This wasn't terrible, but because it had almost every actor in it, it slowed down merging times in BCML quite a lot. There was no real need for all 2044 actors to be loaded when only 5 were used in the mod.My alternative at the time was to take the actors used and put them into my mod.
This was an okay solution, but it got difficult to keep track of which actors were used as the mod expanded.So this is what ActorLoader is for, it gets every C-Actor used by reading the mods smubin files, then copies them into the mods content folder.If you have any questions, feel free to ask them in the comments or on myDiscord server.UsageIn the root folder of your mod (the folder containing aoc, content, etc . . .)  type actor-loader.exe in the file path.Note: in previous versions it was required to append 'C' to new actors, this is no longer required.
Package: actors
A python actor framework.FeaturesEasy to build concurrency with the actor model.Lightweight. Can run millions of actors on a single thread.Integrated supervision for managing actor lifetime and faults.Extensible with new executors and dispatchers.An Akka-like API.InstallationInstall fromPyPIusingpip:$pipinstallactorsObligatory greeterfromactorsimportActor,ActorSystemclassGreeter(Actor):defreceive(self,message):print("Hello%s"%message)system=ActorSystem()greeter=system.actor_of(GreetingActor)greeter.tell("world")system.terminate()DocumentationDocumentation is available athttp://pythonhosted.org/actors/.
Package: actpdf
actpdfinstallationfor Windows operating system:install python:https://www.python.org/downloads/windows/create virtualenv:python -m venv envactivate it:.\env\Scripts\activateinstallGTK3to fixlibcairo-2.dll error. see:weasyprint installion guide.installWe use weasyprint 52.4, sinceWeasyPrint 53 requires at least Pango 1.44.$ pip install actpdf
$ actpdfpackaging: Update VersionUpdating your distribution Down the road, after you’ve made updates to your distribution and wish to make a new release:pip install build
pip install twinedelete files indistfolderincrement the version number in yoursetup.cfgfile$ python3 -m buildFirst upload to TestPypi:$ twine upload --repository testpypi dist/*
# to get password see https://test.pypi.org
$ pip install --index-url https://test.pypi.org/simple/ --no-deps actpdfUpload package to the Python Package Index:$ twine upload dist/*see:https://packaging.python.org/tutorials/packaging-projects/completed templates:allergynutritionhealthfitness_quanutritionnutrition_quanutritionfitnessdetoxskinpgxpersonalitycarriersleeptools: pdf to html converterhttps://idrsolutions.com/online-pdf-to-html-converter