Saravanan666/pypi-org huggingface dataset:
Package: active-pr
active_pran active report of PRs in the github.installpipinstallactive_praccess tokenWe should get a reading only github tokenherefor access, and set in our env.exportGITHUB_TOKEN=<yourtoken>usageexport|grep"GITHUB_TOKEN"GITHUB_TOKEN=<githubtoken># search created_at='begin..end' and state is the current state.active_pr\--authorkyoto7250\--begin2023-04-01\--end2023-04-30\--typeboth\--stateclosed# --github-token <github token>|repo_name|type|title|created_at|closed_at||-----------------------|--------|----------------------------------------------------------------------------------------------------------------------|--------------|-------------||astral-sh/ruff|PR|[[`flake8-simplify`]Implement`dict-get-with-none-default`(`SIM910`)](https://github.com/astral-sh/ruff/pull/3874)|2023-04-04|2023-04-04||astral-sh/ruff|PR|[Supportsmorecasesin`SIM112`](https://github.com/astral-sh/ruff/pull/3876)|2023-04-04|2023-04-04||dondongwon/LPMDataset|ISSUE|[Whereisthe`scrape_scope`columnat`raw_video_links.csv`?](https://github.com/dondongwon/LPMDataset/issues/3)|2023-04-25|2023-06-07|contributeIf you have suggestions for features or improvements to the code, please feel free to create an issue or PR.
Package: active-pre-train-ppg
Unsupervised On-Policy Reinforcement LearningThis work combinesActive Pre-Trainingwith an On-Policy algorithm,Phasic Policy Gradient.Active Pre-TrainingIs used to pre-train a model free algorithm before defining a downstream task. It calculates the reward based on an estimatie of the particle based entropy of states. This reduces the training time if you want to define various tasks - i.e. robots for a warehouse.Phasic Policy GradientImproved Version of Proximal Policy Optimization, which uses auxiliary epochs to train shared representations between the policy and a value network.
Package: activereader
activereaderPython library for reading Garmin TCX and GPX running activity files.Exampleactivereader provides theTcxandGpxfile reader classes.TCX and GPX files can be exported fromGarmin Connect.UseTcxto read and access data from a TCX file:importpandasaspdfromactivereaderimportTcxreader=Tcx.from_file('tests/testdata.tcx')# Build a DataFrame using only trackpoints (as records).initial_time=reader.activity_start_timerecords=[{'time':int((tp.time-initial_time).total_seconds()),'lat':tp.lat,'lon':tp.lon,'distance':tp.distance_m,'elevation':tp.altitude_m,'heart_rate':tp.hr,'speed':tp.speed_ms,'cadence':tp.cadence_rpm,}fortpinreader.trackpoints]df=pd.DataFrame.from_records(records)BackgroundThis project originated as the file-reading part of myheartandsole package.
Lately, I've been interested in keeping my work in more self-contained modules
with lighter dependencies, so I split it out.The idea is to provide a simple API for accessing data from Garmin files, similar
to the waypython-fitparseprovides access to Garmin's impenetrable.fitfiles. I don't aim to do everything,
though; I want to just focus on activity files that represent runs (and maybe walks/hikes)
for now. When I try to cover all cases, the schemas and profiles quickly grow out of
control. Garmin seems to have a reputation for making their files indecipherable, and
I like solving puzzles, so I will focus on translating Garmin's language into human language.
This is in opposition to waiting for Garmin to document all the features of all its files.Tangent time: when I was working on picking apart Garmin's.fitfile structure with my own
device's files, there were a number of undocumented, indecipherable fields. Add to that,
Garmin does not seem to keep documentation online for its older.fitSDKs, so if your
device uses an older one, you might just be out of luck trying to decipher it. I would
rather keep my own separate source of truth, than count on Garmin's being forthcoming
with info.Dependencies and Installationlxmlandpython-dateutilare required.The package is available onPyPiand can be installed withpip:$ pip install activereaderLicenseThis project is licensed under the MIT License. SeeLICENSEfile for details.Project StatusThe project has reached a stable point and I don't expect to be changing much
for now - future versions will likely build on what's here. But sometimes I
change my mind and tear everything apart, so who knows. This package will
remain focused on extracting data from GPX and TCX files...of that I feel sure.CompleteDevelop capability to read runningtcxandgpxfiles.Current ActivitiesHandle pauses and laps in files (things I avoid in my own workouts
because they complicate and obscure the DATA!). The body keeps the score,
but the watch keeps the stats.Future WorkExpand capability to read running activity files.pwx(is this Garmin?)Make a project wiki so I can be as verbose as I please.
(You mean this isn't you being verbose?)ContactReach out to me at one of the following places!Website:trailzealot.comLinkedIn:linkedin.com/in/aarondschroederTwitter:@trailzealotInstagram:@trailzealotGitHub:github.com/aaron-schroeder
Package: active-record-mc
This module implements a simple ORM for basic operations in SQLite databases.The module is derived from a working example of the active record pattern created
by Chris Mitchell to supplement a talk given at the Oregon Academy of Sciences
meeting on January 26, 2011.The example is published on GitHub ashttps://github.com/ChrisTM/Active-Record-Example-for-a-Gradebookand the code is understood to be freely available under the MIT license as above.The original code has been modified so thatThe column names in the selected table are obtained automatically by introspection of the database.The primary key column is no longer required to be 'pk'.Errors are reported via a dialog box.
Package: active_redis
# Example:from active_redis import ActiveRedis, ActiveRedisModel, UUIDGeneratorclass Movie(ActiveRedisModel):stored_attrs = ['title', 'year', 'author']def __init__(self, uuid, title, year, author):self.uuid = uuidself.title, self.year, self.author = title, year, authorif __name__ == '__main__':ActiveRedis.config = {'connexion': {'db': 3},'namespace_prefix': 'mycinema'}assert Movie.delete_all()assert 0, Movie.count()topgun = Movie(UUIDGenerator.generate(), 'TopGun', 1987, 'Tony S.')assert topgun.save()titanic = Movie(UUIDGenerator.generate(), 'Titanic', 1997, 'James C.')assert titanic.save()topgun.update_attr('title', 'Top Gun')assert 'Top Gun', Movie.find(topgun.uuid).titleassert 2, Movie.count()assert 2, len(Movie.find_all())m = Movie.find(topgun.uuid)m.delete()assert 1, Movie.count()assert 1, len(Movie.find_all())
Package: active-semi-supervised-clustering
active-semi-supervised-clusteringActive semi-supervised clustering algorithms for scikit-learn.AlgorithmsSemi-supervised clusteringSeeded-KMeansConstrainted-KMeansCOP-KMeansPairwise constrained K-Means (PCK-Means)Metric K-Means (MK-Means)Metric pairwise constrained K-Means (MPCK-Means)Active learning of pairwise clusteringExplore & ConsolidateMin-maxNormalized point-based uncertainty (NPU) methodInstallationpip install active-semi-supervised-clusteringUsagefromsklearnimportdatasets,metricsfromactive_semi_clustering.semi_supervised.pairwise_constraintsimportPCKMeansfromactive_semi_clustering.active.pairwise_constraintsimportExampleOracle,ExploreConsolidate,MinMaxX,y=datasets.load_iris(return_X_y=True)First, obtain some pairwise constraints from an oracle.# TODO implement your own oracle that will, for example, query a domain expert via GUI or CLIoracle=ExampleOracle(y,max_queries_cnt=10)active_learner=MinMax(n_clusters=3)active_learner.fit(X,oracle=oracle)pairwise_constraints=active_learner.pairwise_constraints_Then, use the constraints to do the clustering.clusterer=PCKMeans(n_clusters=3)clusterer.fit(X,ml=pairwise_constraints[0],cl=pairwise_constraints[1])Evaluate the clustering using Adjusted Rand Score.metrics.adjusted_rand_score(y,clusterer.labels_)
Package: activesoup
A simple library for interacting with the web from pythonDescriptionactivesoupcombines familiar python web capabilities for convenient
headless “browsing” functionality:Modern HTTP support withrequests-
connection pooling, sessions, …Convenient access to the web page with an interface inspired bybeautifulsoup-
convenient HTML navigation.Robust HTML parsing withhtml5lib- parse the web
like browsers do.Full documentation can be found athttps://activesoup.dev.Use casesactivesoupaims to provide just enough functionality for basic web automation
/ crawler tasks. Consider usingactivesoupwhen:You’ve already checked outrequests-htmlYou need to actively interact with some web-page from Python (e.g. submitting
forms, downloading files)You don’t control the site you need to interact with (if you do, just make an
API).You don’t need javascript support (you’ll needseleniumorphantomjs).Usage examplesIn the example below, we’ll load a page with a simple form, enumerate
the fields, and make a submission:>>>importactivesoup>>># Start a session>>>d=activesoup.Driver()>>>page=d.get("https://httpbin.org/forms/post")>>># conveniently access elements, inspired by BeautifulSoup>>>form=page.form>>># get the power of raw xpath search too>>>form.find('.//input[@name="size"]')BoundTag<input>>>># any element, searching by attribute>>>form.find('.//*',name="size")BoundTag<input>>>># or just search by attribute>>>form.find(name="size")BoundTag<input>>>># inspect element attributes>>>print([i['name']foriinform.find_all('input')])['custname','custtel','custemail','size','size','size','topping','topping','topping','topping','delivery']>>># work actively with objects on the page>>>r=form.submit({"custname":"john","size":"small"})>>># responses parsed and ready based on content type>>>r.keys()dict_keys(['args','data','files','form','headers','json','origin','url'])>>>r['form']{'custname':'john','size':'small','topping':'mushroom'}>>># access the underlying requests.Session too>>>d.session<requests.sessions.Sessionobjectat0x7f283dc95700>>>># log in with cookie support>>>d.get('https://httpbin.org/cookies/set/foo/bar')>>>d.session.cookies['foo']'bar'
Package: active-subspaces
Python utilities for working with active subspaces.WARNING: Development is very active right now, so the interfaces are far from
stable. It should settle down by mid-March, when the Active Subspaces book
comes out.Right now I’m using Enthought’s Python Distribution and Canopy for development.
You’ll need numpy and scipy for these tools.You also need a linear program and quadratic program solver. I’m using Gurobi;
you can see the gurobi_wrapper.py that solves the problems I need. To get
Gurobi’s Python interface working with Enthought/Canopy, take a look at this
thread:https://groups.google.com/forum/#!searchin/gurobi/canopy/gurobi/ArCkf4a40uU/R9U1XFuMJEkJQuestions? Contact Paul Constantine at Colorado School of Mines. Google me
for contact info.
Package: activetick-http
activetick_httpPython module that connects to ActiveTick HTTP proxy and supplies Pandas DataFrames.
Requires requests for the quoteStream, and redis for caching.Currently unstable, may end up changing the methods from camelCase to pep8 snake_case.tests run usingpytestHow to use:Run the
HTTP proxy supplied byActiveTickand instantiate ActiveTick, the defaults are shown with a Redis cache enabled:from activetick_http import ActiveTick

# Import the StrictRedis client to enable local persistent caching
from redis import StrictRedis

# ActiveTick initialized with Redis caching enabled (requires Redis)
at = ActiveTick(host='127.0.0.1', port=5000, cache=StrictRedis(host='127.0.0.1'))>From the ActiveTick instance we have access to all the functionality provided by the HTTP proxy with the following methods:quoteDataquoteData(symbols, fields)Returns instantaneous quote information (fields) on symbols
checkquote_fields.pyfor available options.:fields = ['LastPrice', 'BidPrice', 'AskPrice']
df = at.quoteData(('SPY', 'TLT', 'TVIX'), fields)
print(df[fields].head())LastPriceBidPriceAskPriceSPY216.3216.46216.55TLT137.51137.02137.5TVIX18.1518.218.25quoteStreamquoteStream(symbols)Returns a live updated quote stream iterator:stream = at.quoteStream(('NUGT','DUST'))
for tick in stream:
    print(tick)TODO: example dfbarDatabarData(symbol,historyType='I',intradayMinutes=60, beginTime=datetime, endTime=datetime)Returns OHLCV data for singular symbol:df = at.barData('INTC', historyType='I', beginTime=datetime(datetime.now().year, 9, 27))
print(df.head())openhighlowclosevolume2016-09-28 09:00:0037.5237.5237.2537.3951.79294e+062016-09-28 10:00:0037.437.4637.2737.311.59818e+062016-09-28 11:00:0037.3137.3237.1537.281.32702e+062016-09-28 12:00:0037.2837.3237.237.272.39398e+062016-09-28 13:00:0037.27537.3937.2237.371.23249e+06tickDatatickData(symbol, trades=False, quotes=True, beginTime=datetime, endTime=dateime)Returns historical tick level quote and trade data for a symbol:df = at.tickData('GDX', trades=True, quotes=False)
print(df.head())typelastlastzlastxcond1cond2cond3cond42016-09-28 09:30:00.091000T26.2752073P001702016-09-28 09:30:00.091000T26.2752073P160002016-09-28 09:30:00.182000T26.25211T012002016-09-28 09:30:00.184000T26.2589T37121402016-09-28 09:30:00.185000T26.25500T012140optionChainoptionChain(symbol)Returns the symbols making up the optionchain for the underlying:df = at.optionChain('SPY')
print(df.head())0OPTION:SPY—161014P001860001OPTION:SPY—161012C001970002OPTION:SPY—161014C001870003OPTION:SPY—161014P001920004OPTION:SPY—161012P00193000
Package: activetigger
(py) Active TiggerPython refactoring of ActiveTigger (Julien Boelaert & Etienne Ollion)https://gitlab.univ-lille.fr/julien.boelaert/activetiggerWork in progress ...Current roadmapTo add : history of actionsTo add : multiuserTo add : queue management (rq)To add : test unitsTechnical specificationsREST-like client/server architectureMixed data storage : sqlite + filesBackend PythonFastAPIindependant Processes to CPU-bound tasts (embeddings/bertmodels)FrontendIPython widgetTo do : Javascript (React ? Vue ?)
Package: active-time-scheduling
DescriptionThis package comprises various algorithms for solving the Active Time Problem developed to this date. The following
table provides a list of the implemented algorithms available in the subpackageschedulersand the corresponding
articles where these algorithms were developed.SchedulerReferenceLazyActivationSchedulerNLogN"A model for minimizing active processor time" (Chang et al., 2012)LazyActivationSchedulerT"A model for minimizing active processor time" (Chang et al., 2012)MatchingScheduler"A model for minimizing active processor time" (Chang et al., 2012)DegreeConstrainedSubgraphScheduler"A model for minimizing active processor time" (Chang et al., 2012)GreedyScheduler"Brief announcement: A greedy 2 approximation for the active time problem" (Kumar and Khuller, 2018)GreedyIntervalsScheduler--MinFeasScheduler"LP rounding and combinatorial algorithms for minimizing active and busy time" (Chang et al., 2017)GreedyLocalSearchScheduler"Brief announcement: A greedy 2 approximation for the active time problem" (Kumar and Khuller, 2018)GreedyLowestDensityFirstScheduler--BruteForceSchedulerUsed for testingLinearProgrammingScheduler"A model for minimizing active processor time" (Chang et al., 2012)LinearProgrammingRoundedScheduler"LP rounding and combinatorial algorithms for minimizing active and busy time" (Chang et al., 2017)BatchScheduler"Optimal batch schedules for parallel machines" (Koehler and Khuller, 2013)Usage ExamplesTo create a job set, the subclasses ofAbstractJobPoolfrom the subpackagemodelsare used. Different subclasses can be
to represent different properties for the jobs in them, for exampleFixedLengthJobPooldemands a fixed length from its
jobs. The following example demonstrates the process of creating a job pool and adding a job to it:frommodelsimportJobPooljob_pool=JobPool()job_pool.add_job(release_time=5,deadline=8,duration=2)To process the job pool, the subclasses ofAbstractSchedulerfrom the subpackageschedulersare used. To perform the
processing, the job pool should be passed into theprocessfunction. The result of the function is the computed job
schedule, which, if the problem instance is feasible, contains the information regarding the active time slots as well as
individual schedules:fromschedulersimportFlowMethod,GreedySchedulerscheduler=GreedyScheduler(FlowMethod.PREFLOW_PUSH)schedule=scheduler.process(job_pool,max_concurrency=2)
Package: activeworkflow-agent
ActiveWorkflow Agent for PythonThis library helps you to write your ownActiveWorkflowagents inPythonusing ActiveWorkflow'sremote agent API.InstallationTo install this library run:python-mpipinstallactiveworkflow_agentPython >= 3.7 is supported.DocumentationFor full documentation please seeActiveWorkflow Agent Pythonon ActiveWorkflow's documentation website.LicenseThe library is available as open source under the terms of theMIT License.
Package: activipy-pgsql
An activipy environment to use PostgreSQL as the data store for ActivityStream
objects.Theactivipy moduleenables the
use ofActivityStreamsin
your applications and includes the support of different “environments” to
extend functionality.This package provides a “pgsql” environment that maps storage methods to
PostgreSQL queries using psycopg2. Object data is stored using the jsonb
data type to simplify the schema and provide maximum performance.Example CodeOpen a database:>>> from activipy import core, vocab
>>> from activipy.pgsql import pgsql
>>> db = pgsql.JsonPgSQL.open(
... host="<db_server>", dbname="<db_name>",
... user="<db_user>", password="<db_user_pass>")
>>> env = pgsql.PgSQLNormalizedEnvCreate a new record and save to database:>>> post_this = core.ASObj({
...     "@type": "Create",
...     "@id": "http://tsyesika.co.uk/act/foo-id-here/",
...     "actor": {
...         "@type": "Person",
...         "@id": "https://tsyesika.co.uk/",
...         "displayName": "Jessica Tallon"},
...     "to": ["acct:cwebber@identi.ca",
...            "acct:justaguy@rhiaro.co.uk",
...            "acct:ladyaeva@hedgehog.example"],
...     "object": {
...         "@type": "Note",
...         "@id": "https://tsyesika.co.uk/chat/sup-yo/",
...         "content": "Up for some root beer floats?"}},
... pgsql.PgSQLNormalizedEnv)
>>> post_this.m.save(db)
{'@type': 'Create',
 '@id': 'http://tsyesika.co.uk/act/foo-id-here/',
 'actor': 'https://tsyesika.co.uk/',
 'to': ['acct:cwebber@identi.ca',
        'acct:justaguy@rhiaro.co.uk',
        'acct:ladyaeva@hedgehog.example'],
 'object': 'https://tsyesika.co.uk/chat/sup-yo/'}Note how in this example the record has been normalized. In this environment
the actor and object are created in separate records and made into references
in the parent record.  To retrieve the original denormalized form:>>> normalized_post = pgsql.pgsql_fetch(
... "http://tsyesika.co.uk/act/foo-id-here/", db, env)
>>> normalized_post.m.denormalize(db)
<ASObj Create "http://tsyesika.co.uk/act/foo-id-here/">
>>> normalized_post.m.denormalize(db).json()
{'to': ['acct:cwebber@identi.ca',
        'acct:justaguy@rhiaro.co.uk',
        'acct:ladyaeva@hedgehog.example'],
 '@id': 'http://tsyesika.co.uk/act/foo-id-here/',
 '@type': 'Create',
 'actor': {'@id': 'https://tsyesika.co.uk/',
           '@type': 'Person',
           'displayName': 'Jessica Tallon'},
 'object': {'@id':
            'https://tsyesika.co.uk/chat/sup-yo/',
            '@type': 'Note',
            'content': 'Up for some root beer floats?}}
Package: activity-detection-evaluation
Activity Detection Evaluation FrameworkThe purpose of this library is to provide an easy and standard way for evaluating activity detection comprehensively. In this context, activity detection is associated with any kind of detection involving the identification of time segments (or intervals) that contain relevant activity inside a timed sample. Given a signal that contains an activity occuring from time X to Y, this framework will evaluate how precisely predictions match the occurance of this activity.A task that can be evaluated using this framework is voice activity detection (VAD). The purpose of this task is to identify what parts of an audio clip contain voiced activity. By providing the time intervals that your detector predicted as having voice activity and those given by ground truth, this module will output several metrics that will reflect how well the detector is performing.Expected formatsGiven the vast ammount of annotation and model prediction schemes out there, it is necessary to standardize annotations and predictions to make evaluation easier.Annotation SchemeThe library expects annotations to be formated according to the following example:{"sample1.wav":[{"category":"activity_1","s_time":0,"e_time":2300},{"category":"activity_1","s_time":5200,"e_time":7800},...],"sample2.wav":[],"sample3.wav":[{"category":"activity_2","s_time":152,"e_time":3000}]...}For each files_timeis the time at which the activity started ande_timethe time at which the activity ended, both in ms. The remaining time intervals inside the sample are automatically considered as a "background" class.A labelcategoryis also included to identify the kind of activity being labeled. Though activity detection most often means a binary classification of samples (has activity or not), we find that by providing annotations with richer information of possible sources of error or truth for those activites can help illustrate what are the weakneses and strengths of the detection system.For example, consider the case in which we wish to detect the times when a flock of birds crosses the sky. In our annotations, we may also include the time intervals when other animal species are moving, so to identify cases when the system gets tricked by these situations.Predictions schemeFor predictions, the library follows a similar structure as the annotation scheme:{"sample1.wav":[[100,4000],[6000,10000]...],"sample2.wav":[1000,10000],"sample3.wav":[]...}In this case, each file sample has an array containing the time intervals in which activity was predicted. So, considering the file "sample1.wav" shown above, the predictions indicate the model predicted activity occuring between 100-4000 ms and 6000-10000 ms.