Saravanan666/pypi-org huggingface dataset:
Package: timeseriesql-appoptics
TimeSeriesQLA Pythonic query language for time series dataTable of ContentsAbout the ProjectBuilt WithGetting StartedPrerequisitesInstallationUsageRoadmapContributingLicenseContactAcknowledgementsAbout The ProjectThis project add AppOptics as a backend for the TimeSeriesQL ecosystem.Built WithTimeSeriesQLrequestsGetting StartedTo get a local copy up and running follow these simple steps.PrerequisitesThe requirements are in therequirements.txtfile.Installationpippipinstalltimeseriesql-appopticsmanualClone the timeseriesql-appopticsgitclonehttps:://github.com/mbeale/timeseriesql-appoptics.gitInstall librarycdtimeseriesql-appoptics
pythonsetup.pyinstallUsageAppopticsis a commercial time series database product.  The backend converts a query into an
API call.The backend expects aAPPOPTICS_TOKENenvironment variable to be set in order to authenticate to AppOptics.AppOptics Queryfromtimeseriesql_appopticsimportAOBackenddata=AOBackend(xforxin"metric.name")['1h']#basicdata=AOBackend(x*100forxin"metric.name")['1h']#binary operations (+, -, /, *)data=AOBackend(x*1.8+32forxin"metric.name")['1h']#multiple binary operations (°C to °F)data=AOBackend(x.maxforxin"metric.name")[3600:]#get max valueAppOptics FilteringCurrently only==and!=are supported.fromtimeseriesql_appopticsimportAOBackenddata=AOBackend(xforxin"metric.name"ifx.environment=='production')[3600:]AppOptics Groupingfromtimeseriesql_appopticsimportAOBackenddata=AOBackend(xforxin"metric.name").group('environment')[3600:]data=AOBackend(x-yforx,yinAOBackend((x.maxforxin"metric1"),(x.minforxin"metric2")).by('tag1'))[3600:]AppOptics Timefromtimeseriesql_appopticsimportAOBackenddata=AOBackend(xforxin"metric.name")[:]#no start or end time (not recommended)data=AOBackend(xforxin"metric.name")[3600:]#from now - 3600 seconds until now, resolution of 1data=AOBackend(xforxin"metric.name")[3600:1800]#from now - 3600 seconds until now - 1800 seconds, resolution of 1data=AOBackend(xforxin"metric.name")[3600::300]#from now - 3600 seconds until now resoultion of 300 secondsAppOptics Functionsdata=AOBackend(sum(derive(x))forxin"metric.name")[3600:]#get the sums of the derivativesdata=AOBackend(zero_fill(x)forxin"metric.name")[3600::60]#zero_fillAppOptics Raw Compositedata=AOBackend('s("some_metric", "*")')[3600:]RoadmapSee theopen issuesfor a list of proposed features (and known issues).ContributingContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make aregreatly appreciated.Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestLicenseDistributed under the MIT License. SeeLICENSEfor more information.ContactMichael Beale -michael.beale@gmail.comProject Link:https://github.com/mbeale/timeseriesql-appoptics
Package: timeseriesql-matplotlib
TimeSeriesQL-MatplotlibA plotting backend for the TimeSeriesQL libraryTable of ContentsAbout the ProjectBuilt WithGetting StartedPrerequisitesInstallationUsageRoadmapContributingLicenseContactAcknowledgementsAbout The ProjectThis project adds a matplotlib plotting backend for the TimeSeriesQL project.Built WithTimeSeriesQLMatplotlibGetting StartedTo get a local copy up and running follow these simple steps.PrerequisitesThe requirements are in therequirements.txtfile.Installationpippipinstalltimeseriesql-matplotlibmanualClone the timeseriesql-matplotlibgitclonehttps:://github.com/mbeale/timeseriesql-matplotlib.gitInstall librarycdtimeseriesql-matplotlib
pythonsetup.pyinstallUsageThe charting library operates on TimeSeries objects.  The Axes can be overriden to control the placement of the charts.  All the below examples use the following code:importmatplotlib.pyplotaspltfromtimeseriesql_matplotlibimportMatplotlibTQLasmpfromtimeseriesql.backends.csv_backendimportCSVBackenddata=CSVBackend(xforxin"AAPL.csv")[:]#CSV of AAPL stock data header = (open, close, high, low, adj close)Line Plotmp().line_plot(data)plt.show()Stacked Plotmp().stacked_plot(data)plt.show()Timebox Plotmp().line_plot(data)timebox_plot(data[:,0])"""the plot arguement defaults to auto but you can set a specific periods    - second bucketsm    - minute bucketsh    - hour bucketsd    - day bucketsmth  - month bucketsy    - year buckets"""Distribution Plotmp().dist_plot(data[:,0],percentiles=[25,75])#percentiles are optionalplt.show()Correlogram Plotmp().correlogram_plot(data)plt.show()Text Plotmp().line_plot(data)mp().text_plot(data[-1,0],title="A Nice Text Box",thresholds=[(0,'green','white'),(20,'cornflowerblue','white'),(None,'darkorange','white')])Layout Examplefrommatplotlib.gridspecimportGridSpecfig=plt.figure(constrained_layout=True,figsize=(20,20))gs=GridSpec(4,4,figure=fig)ax1=fig.add_subplot(gs[0,0])ax2=fig.add_subplot(gs[0,1])ax3=fig.add_subplot(gs[0,2])ax4=fig.add_subplot(gs[0,3])ax5=fig.add_subplot(gs[1:3,:3])ax6=fig.add_subplot(gs[1,3])ax7=fig.add_subplot(gs[2,3])ax8=fig.add_subplot(gs[3,:2])ax9=fig.add_subplot(gs[3,2:])mp().text_plot(data[:,0].mean(),ax=ax1,title="Avg Close")mp().text_plot(data[:,1].mean(),ax=ax2,title="Avg High")mp().text_plot(data[:,2].mean(),ax=ax3,title="Avg Low")mp().line_plot(data[:,0],ax=ax4)mp().line_plot(data,ax=ax5)mp().line_plot(data[:,1],ax=ax6)mp().line_plot(data[:,2],ax=ax7)mp().line_plot(data[:,3],ax=ax8)mp().line_plot(data[:,4],ax=ax9)RoadmapSee theopen issuesfor a list of proposed features (and known issues).ContributingContributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make aregreatly appreciated.Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestLicenseDistributed under the MIT License. SeeLICENSEfor more information.ContactMichael Beale -michael.beale@gmail.comProject Link:https://github.com/mbeale/timeseriesql-matplotlib
Package: timeseries-qmc
TimeseriesQMCThis is a python library for running and testing the time-seriers quantum Monte Carlo algorithm of model Hamiltonians.
Time-series quantum Monte Carlo is a hybrid classical-quantum algorithm for evaluting finite-temperature obervables
by sampling easily preparable states and estimating their thermal weights from real-time dynamics simulated on a quantum
computer.This library was developed by the condesend matter group ofQuantinuum.Getting startedThis library is available for Python>=3.8 on Linux and MacOS.
To install it, run:pipinstalltimeseries-qmcThis automatically installs all the dependecies except forQuSpin.
For instructions on the best practice for installing QuSpin alongside other pip packages check ourinstallation guide.Full documentation of thetimeseries-qmcpackage can be foundhere.
It includes anAPI reference,examplesand atutorialfor a quick introduction on how to use the library.How to citeIf you use this library for a work published in an academic journal, we apperciate citingthis paperto acknowledge the effort put into the development.AcknowledgmentThis work was supported by the German Federal Ministry of Education and Research (BMBF) through the projectEQUAHUMO(grant number 13N16069) within the funding program quantum technologies - from basic research to market.LicenseThe code is licensed underApache License Version 2.0.
Package: timeseriesqualitycheck
timeseriesqualitychecktimeseriesqualitycheckis a Python package designed to assess the quality of time-series data. It provides a straightforward way to evaluate the integrity and cleanliness of time-series datasets by analyzing their Time Pattern Cohesion Score (TPCS) and Signal-to-Noise Ratio (SNR).InstallationTo installtimeseriesqualitycheck, simply use pip:pipinstalltimeseriesqualitycheckcheck_quality Functioncheck_qualityrequires a signal input in pandas DataFrame format, with at least two columns:y: column where the values of the signal are stored.ds: column where the date information is stored.TheEND_OF_TIMEparameter is useful when we have extra information about the time period for the signal.
For example, the signal may have values until May but should also include values for April.
TheEND_OF_TIMEparameter helps determine possible missing values.TheMAX_LEN_MONTHSparameter works in a similar way to theEND_OF_TIMEparameter.
However, its purpose is to gauge the existence of missing values from the beginning of the defined data gathering period.The function returns a dictionary of values:cleaning_score_data_dict={"TPC_features":TPC_features,"TPC_score":TPC_score,"SNR_features":SNR_features,"SNR_score":SNR_score,"cleaning_score_weights":cleaning_score_weights,"cleaning_score":cleaning_score,}You can access any value you need; the final output key is"cleaning_score".Usageimportpandasaspdfromtimeseriesqualitycheckimportcheck_qualityEND_OF_TIME=pd.to_datetime("2021-05-01")MAX_LEN_MONTHS=13list_of_timestamps=["2020-05-01","2020-06-01","2020-07-01","2020-08-01","2020-09-01","2020-10-01","2020-11-01","2020-12-01","2021-01-01","2021-03-01","2021-04-01","2021-05-01"]#notice that "2021-02-01" is missinglist_of_timestamps=[pd.to_datetime(e)foreinlist_of_timestamps]signal_values_for_timestamps=[20,30,40,50,600,70,80,70,60,50,40,30]#notice that we have an outlier(600) valuedict={'ds':list_of_timestamps,'y':signal_values_for_timestamps}df=pd.DataFrame(dict)quality_report=check_quality(df,MAX_LEN_MONTHS,END_OF_TIME)print(quality_report)DescriptionThecheck_qualityfunction evaluates the quality of a time-series signal. It analyzes the signal for pattern consistency, contiguity, and noise levels to produce a comprehensive quality score.Syntaxtimeseriesqualitycheck.check_quality(signal_df,MAX_LEN_MONTHS,END_OF_TIME,tpcs_limit_for_snr_calculationt=3.5)Parameterssignal_df(pd.DataFrame): A pandas DataFrame containing the time-series data with 'y' and 'ds' columns.MAX_LEN_MONTHS(int): The maximum length of the time series in months.END_OF_TIME(datetime): The end date for the time series data.snr_limit(float, optional): The threshold for the signal-to-noise ratio. Default is 3.5.Returnsdict: A dictionary containing the cleanliness score, TPC and SNR features, and detailed scores.ContributingContributions totimeseriesqualitycheckare welcome. Please ensure that your code adheres to the project's coding standards and includes appropriate tests.LicenseThis project is licensed under theMIT License.Additional Notes on check_quality Function:
Package: timeseriestools
timeseriestoolsfrom timeseriestools import TimeseriesTools
import pandas as pd

tst = TimeseriesTools()
tst.login("info@timeseries.tools", "some-password")


s = pd.Series(index=["2020-01-01", "2020-01-02", "2020-01-03"], data=[1, 2, 3])
s.index = pd.to_datetime(s.index)

tst.create_tearsheet(s)
Package: time-series-transformer
Transformers for Time SeriesBased ontimeseriestransformer.InstallationWindows:.\scripts\init-env.ps1MacOS / Linux./scripts/init-env.shUsagefromflights_time_series_datasetimportFlightsDatasetfromtime_series_predictorimportTimeSeriesPredictorfromtime_series_transformerimportTransformertsp=TimeSeriesPredictor(Transformer(),max_epochs=50,train_split=None,)tsp.fit(FlightsDataset())TestTo test the package simply run the following command from project's root folder.pytest-s
Package: timeserio
timeseriotimeseriois the missing link betweenpandas,scikit-learnandkeras. It simplifies building end-to-end deep learning models - from a DataFrame through feature pipelines to multi-stage models with shared layers. While initially developed for tackling time series problems, it has since been used as a versatile tool for rapid ML model development and deployment.Loosing track of big networks with multiple inputs and outputs? Forgetting to freeze the right layers?
Struggling to re-generate the input features?timeseriocan help!Documentation and TutorialsPlease see theofficial documentationon how to get started.FeaturesEnable encapsulated, maintainable and reusable deep learning modelsFeed data frompandasthroughscikit-learnfeature pipelines to multiple neural network inputsManage complex architectures, layer sharing, partial freezing and re-trainingProvide collection of extensible building blocks with emphasis on time series problemsInstallationpip install timeserio, or install from source -pip install -e .SeeGetting StartedDevelopmentWe welcome contributions and enhancements to any part of the code base, documentation, or tool chain.SeeCONTRIBUTING.mdfor details on setting up the development environment, running tests,
etc.
Package: timesetter
User GuideTimesetter is a Python package to set system time regardless of operating systemSupported PlatformsWindowsLinuxmacOSTipsThis package aims to set system time in the precision of below milliseconds.You need to pass a datetime object to thesetfunction. If the timezone information was not included in the time object(naive), the package will assume that it's identical to the system.You need to run your Python code with administration privileges for this package to work properly. Otherwise,PermissionErrorwill be raised. This applies to all platforms.How to UseInstall the package from PyPIpip install timesetterThen import it in your Python codefrom datetime import datetime
import timesetter

target_time = datetime(year=2021, month=3, day=29, hour=15, minute=38, second=12)
timesetter.set(target_time)For MaintainersRulesType hints as well as stub files for Python should be provided for the maintainability of the code. Turn on strict type checking in whatever IDE you are using. If some third party packages doesn't support type checking very well, then you can write# type: ignoreto suppress the warning.Command Line ScriptsInstall packages written inrequirements.txtfrom PyPIpip install -r ./requirements.txtGenerate the distribution archive to/distpython -m buildUpload the package to PYPIpython -m twine upload dist/*
Package: timeshade
Shade nighttime dark on plotsInstallpip install timeshadeUsageimporttimeshade;importpandasaspd# create timeseriesidx=pd.date_range("2018-01-01",periods=100,freq="H")ts=pd.Series(range(len(idx)),index=idx)# shadeimporttimeshadetimeshade.shade(ts)# plotimportmatplotlib.pyplotaspltplt.show()
Package: timesheet
install$ pip install timesheetusage$ timesheet help
usage: timesheet [-h]
                 {help,start,end,active,report,subjects,import,export,edit-last,abort,rename,daily-report,daily-detail,delete,version}
                 ...

Simple timesheet system.

optional arguments:
  -h, --help            show this help message and exit

Commands:

  {help,start,end,active,report,subjects,import,export,edit-last,abort,rename,daily-report,daily-detail,delete,version}
    help                Prints help for given command
    start               Starts a task
    end                 Ends a task
    active              Prints active task
    report              Print report about an subject or all subjects
    subjects            Print all subjects
    import              Import csv file with columns: subject, task, start,
                        end
    export              Export the database into csv file with columns:
                        subject, task, start, end
    edit-last           Edit last task
    abort               Aborts currently active task
    rename              Renames a subject
    daily-report        Print daily report
    daily-detail        Print detailed daily report
    delete              Deletes a subject
    version             Prints the versionHelp on Help$ timesheet help -h
usage: timesheet help [-h] [command]

positional arguments:
  command     Command to print help about that

optional arguments:
  -h, --help  show this help message and exitBash Auto-Completion$ echo "eval \"\$(register-python-argcomplete timesheet)\"" >> ~/.bashrc
$ source ~/.bashrcChange Log0.9.2Supporting python30.8.4Adding daily-report command bysonologicReformatting README.md to README.rst for pypiUpdating README.rst
Package: timeship
TimeshipThe timeship lets you easily and transparently time execution times within your python code.Its concept is that you set anchors in your code specifying timing routes. The timeship module will time the specified routes and transparently inform you about their execution time.installationTimeship can be installed usingpipvia:pipinstalltimeshipdemoSimply execute the following python snippet to see the timeship on sea!importtimefromtimeshipimporttimeshipwithtimeship.Anchor("BuildShip"):withtimeship.Anchor("CollectMaterial"):time.sleep(0.2)withtimeship.Anchor("CarftHull"):time.sleep(0.3)withtimeship.Anchor("CraftMast"):time.sleep(0.4)withtimeship.Anchor("HoistSail"):time.sleep(0.1)withtimeship.Anchor("Sail"):time.sleep(0.6)timeship.plot("timeship_demo")usageYou have two basic different options to set anchorsthe anchor functionThe fist option is using timeships anchor function as follows:# set anchor Arrrtimeship.anchor("Arrr")# execute codetime.sleep(0.1)# release anchor Arrrtimeship.anchor("Arrr",release=True)# set anchor Orrrtimeship.anchor("Orrr")# execute some codetime.sleep(0.4)# additionally set anchor Errrtimeship.anchor("Errr")# execute some other codetime.sleep(0.4)# release all active anchors by not specifying a nametimeship.anchor()contextsThe second option is to use contextswithtimeship.Anchor("setup"):time.sleep(0.1)nestingThe timeship also supports nested contexts.
Nested timing context can be specified using a slashy (context/subcontext) notation:timeship.anchor("xdata/load")time.sleep(0.1)timeship.anchor()timeship.anchor("xdata/augment")or by nesting contexts:withtimeship.Anchor("ydata"):withtimeship.Anchor("load"):# execute ydata loading codetime.sleep(0.2)withtimeship.Anchor("augment"):# execute ydata augmentation codetime.sleep(0.3)or equivalently:withtimeship.Anchor("zdata/load"):# execute zdata loading codetime.sleep(0.2)withtimeship.Anchor("zdata/augment"):# execute zdata augmentation codetime.sleep(0.3)plotting timing dataAt the end of your code, plot the results by by using theplotfunction. Timeships plotting function (timeship.plot()) creates a directory (specified by thedirargument) with an index.html containing a d3 plot with the timing data which can be viewed through a webbrowser.timeship.plot(dir="timeship")This will create a new directory (in this case called "timeship") and store an html page, which contains a clear visualization of the timing data.Sail on through space and time, Arrr!
Package: timeSHIT
Timesheet-FillerEase the pain of logging your time in JIRA TimesheetsInstallationRun following command to installtimeSHITmodule:pip install timeSHITHow to run?Create aconfig.txtfile with following content:{
    "jira_url": "http://0.0.0.0",
    "username": "[your_username]",
    "password": "[your_password]",
    "timesheet_jira_id": "ABCD-1",
    "hours_to_fill": "8",
    "minutes_to_fill": "0",
    "comment": "[your_comment]"
}Now run following command in the directory where aboveconfig.txtis saved.For Linux:nohup python -m timeSHIT &NoteSupports both Python 2.x and 3.x
Package: timesias
TimesiasForcast outcomes from time-series history. This is the top-performing algorithm forDII National Data Science Challenge.InstallationInstall this package via pip:pipinstalltimesiasor clone this program to your local directory:gitclonehttps://github.com/GuanLab/timesias.gitDependencypython (>3.6)numpy (1.17.2)pandas (0.25.1)LightGBM (3.1.1)scikit-learn (0.19.0)shap (0.38.1)For visualization:boken (2.3.0)Input data formatThe example data in the data/ are randomly generated data for the demonstration of the algorithm.Two types of data is requied for model training and prediction:gs.file: gold standard file with two columns. The first column is paths for time-series records. The second column is the gold standard (0/1), representing the final outbreak of sepsis./data/0.psv,1
./data/1.psv,1
./data/2.psv,0
./data/3.psv,1
./data/4.psv,0
./data/5.psv,1
./data/6.psv,1*.psv: time series record files..psvtable files separated by|, which are the time-series records.
The header of psv file are the feature names. To note, the first column is the time index.HR|feature_1|feature_2|...|feature_n-1|feature_n
0.0|1|0.0|...|1.3|0.0 
1.0|NaN|0.0|...|0.0|0.0
3.5|NaN|2.3|...|0.0|0.0Model training and cross validationtimesias-g[GS_FILE_PATH]-t[LAST_N_RECORDS]-f[EXTRA_FEATURES]-e[EVA_METRICS]--shapGS_FILE_PATH: the path to the gold-standard file; for example,/data/gs.file;LAST_N_RECORDS: last n records to use for prediction. default: 16;EXTRA_FEATURES: addtional features used for prediction. default: ['norm', 'std', 'missing_portion', 'baseline'], which are all features we used in DII Data challenge.EVA_METRICS: evaluation metrics to use. Available choices: auroc auprc cindex pearsonr spearmanr. For binary classification,AUROCandAUPRCare recommended; for regression, we recommend:C-index,PearsonrandSpearmanr. default: AUROC AUPRCalso use:timesias--helpto get instructions on the usage of our program.The above one-line command will yield the following results automatically:./models.: where all hyperparameters of trained models will be saved../results: where all results mentioned below will be stored:eva.tsv: Evaluation results during five-fold cross validation.all results from top feature evaluations if--shapis used. the details will be mentioned in the next section.Top feature evaluationif--shapis indicated, SHAP analysis will be carried out to show top contributing measurements and last nth time points. This will generate an html report (./results/top_feature_report.html) like the following:The corresponding shap values will be stored in./results/shap_group_by_measurment.csvand./results/shap_group_by_timeslot.csv.Other applications of this methodThis method can be generalized to be used on other hospitalization data. One application of this method is theCOVID-19 DREAM Challenge, where this method also achieves top performance.ReferenceFor citation, please refer to our latest iScience paper:Assessment of the timeliness and robustness for predicting adult sepsis.For protocol(TBD)
Package: timesketch-api-client
The Timesketch API client provides you with a set of Python libraries to connect to your Timesketch (https://github.com/google/timesketch) instance.The API is feature complete with the Timesketch UI and allows you to do all operations that can be done in the UI, providing ways to integrate Timesketch into other products such as Jupyter/Colab.To see how it works in action, try the colab notebook that is accessible from here:https://colab.research.google.com/github/google/timesketch/blob/master/notebooks/colab-timesketch-demo.ipynb
Package: timeskorch
Time Skorch (TS) - Deep Learning for Time SeriesTime Skorch (TS) is a powerful tool designed to make time series analysis and forecasting a breeze. Leveraging the capabilities of the popular scikit-learn library and seamlessly integrating with scikit-learn's API, TS provides a simple yet robust solution for working with time series data.
TS provides a simple yet robust solution for working with time series data while leveraging the power of deep learning.What is Time Skorch (TS)?Time series data, with its temporal dependencies, is pervasive in various domains such as finance, healthcare, and environmental sciences. TS is your all-in-one solution for tackling time series challenges. With TS, you can:ForecastingClassification(future work)Imputation(future work)Quick TourDoSomethingGetting StartedTo start using Time Skorch (TS) for your deep learning-based time series projects, simply install it via pip:pipinstalltimeskorchContributingWe welcome contributions from the community to enhance and expand the capabilities of Time Skorch. Feel free to open issues, submit pull requests, or engage in discussions on our GitHub repository.ContactFeel free to contact Mingu Kang (kang.mingu94@gmail.com) if you have any further questions.