Saravanan666/pypi-org huggingface dataset:
Package: turfpy
TurfpyDemo:A Python library for performing geospatial data analysis which reimplements turf.js.InstallationYou can install the Turfpy fromPyPI:pip install turfpyIf you prefer to useconda:conda install -c conda-forge turfpyTest SuiteYou can run the test suite locally:pipinstall-rdev_requirements.txt
pytest-s-v--cov=turfpytestsFeaturesIt supports below features:MeasurementsTransformationsMiscRandomDocumentationDocumentation can be found at:docs
Package: turgles
TurGLESOpenGL ES backend for rendering turtlesStatus: experimenting, pre-alphaHard Goals:Fast renderer for a turtle-like worldRasPi compatibleFull 3d cameraCustom 3D turle geometryScales to 10,000 turtlesStretch Goals:Texture mapping images as turtleDrop in replacement renderer for stdlib turtle module*Use shaders to simulate turtle world, not just renderExtensible (custom turtle shaders, new world objects)* via monkey patching, as turtle module not easily extensibleDevelopmentvirtualenv turgles
pip install -r requirements.txt
Package: turicreate
Turi Create simplifies the development of custom machine learning
models. You don’t have to be a machine learning expert to add
recommendations, object detection, image classification, image
similarity or activity classification to your app.Supported PlatformsTuri Create supports:macOS 10.12+Linux (with glibc 2.12+)Windows 10 (via WSL)System RequirementsPython 2.7, 3.5, or 3.6Python 3.7 macOS onlyx86_64 architectureInstallationPlease see detailed instructions at the project’shomepage.DocumentationThe packageUser
GuideandAPI
Docscontain more
details on how to use Turi Create.
Package: turiean
📦 setup.py (for humans)This repo exists to providean example setup.pyfile, that can be used
to bootstrap your next Python project. It includes some advanced
patterns and best practices forsetup.py, as well as some
commented–out nice–to–haves.For example, thissetup.pyprovides a$ python setup.py uploadcommand, which creates auniversal wheel(andsdist) and uploads
your package toPyPiusingTwine, without the need for an annoyingsetup.cfgfile. It also creates/uploads a new git tag, automatically.In short,setup.pyfiles can be daunting to approach, when first
starting out — even Guido has been heard saying, "everyone cargo cults
thems". It's true — so, I want this repo to be the best place to
copy–paste from :)If you're interested in financially supporting Kenneth Reitz open source, considervisiting this link. Your support helps tremendously with sustainability of motivation, as Open Source is no longer part of my day job.Check out the example!To DoTests via$ setup.py test(if it's concise).Pull requests are encouraged!More ResourcesWhat is setup.py?on Stack OverflowOfficial Python Packaging User GuideThe Hitchhiker's Guide to PackagingCookiecutter template for a Python packageLicenseThis is free and unencumbered software released into the public domain.Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any means.✨🍰✨
Package: turing_21_matrix_operations
ContentsOverviewPrerequisitesInstallationFunctionscreate_random_matrixtranspose2dwindow1dconvolution2dCustom Generic TypesFuture ImprovementsOverviewThis library offerstranspose2d,window1dandconvolution2dfunctions to perform 2D matrix creation, transposition and cross-correlation, and 1D array windowing.These functions are particularly useful for machine learning applications.PrerequisitesPython 3.10 or newer.
Numpy 1.26.1 or newer.Custom Generic TypesWithin this library, there are three custom generic types to streamline function signatures and maintain type consistency, which can be enforced by MyPy:Matrix: Represents a 2D list of floats and is bound toList[List[float]].Array1D: Represents a 1D array, which can either be a Python list or a 1D numpy array. It is defined asTypeVar("Array1D", List[float], np.ndarray).Matrix2D: Represents a 2D numpy array and is bound to np.ndarray.InstallationPackage can be reached manually atPyPi.The library can be installed directly from PyPi:pip install turing_21_matrix_operationsFunctionsCreate Random MatrixThe create_random_matrix function generates a matrix filled with random numbers between 0 and 10.Argumentsrows (int): Number of rows in the matrix.columns (int): Number of columns in the matrix.ReturnsMatrix: 2D list of random floats.Usage:fromturing_21_matrix_operationsimportcreate_random_matrixmatrix=create_random_matrix(3,4)print(matrix)Transpose2DThe transpose2d function is designed to transpose a 2D matrix by swapping its rows and columns.Argumentsinput_matrix (Matrix): 2D list to be transposed.ReturnsMatrix: Transposed 2D list.fromturing_21_matrix_operationsimporttranspose2dmatrix=[[1,2],[3,4],[5,6]]transposed=transpose2d(input_matrix=matrix)print(transposed)Window1DThe window1d function creates overlapping windows of a given size from a 1D list or numpy array.Argumentsinput_array (Array1D): 1D list or numpy array.size (int): Desired window size.shift (int, optional): Window shift size. Default is 1.stride (int, optional): Window stride size. Default is 1.ReturnsList[Array1D]: List of 1D windows.fromturing_21_matrix_operationsimportwindow1dinput_array=[1,2,3,4,5,6,7,8,9,10]windows=window1d(input_array=input_array,size=2,shift=2,stride=2)print(windows)Convolution2DThe convolution2d function performs 2D convolution using a given kernel.Argumentsinput_matrix (Matrix2D): 2D numpy array input matrix.kernel (Matrix2D): 2D numpy array convolution kernel.stride (int, optional): Convolution stride. Default is 1.
ReturnsMatrix2D: Convolved 2D numpy array.fromturing_21_matrix_operationsimportconvolution2dinput_matrix=np.array([[1,2,3],[4,5,6],[7,8,9]])kernel=np.array([[1,0],[0,-1]])convolved=convolution2d(input_matrix=input_matrix,kernel=kernel)print(convolved)
Package: turing-ai
Turing Python Client LibraryThis library provides a straightforward interface for interacting with the
Turing RPC Server. It simplifies the process of sending questions and receiving
answers.Project StructureThe client library is structured into modules within thecoredirectory for
clarity and ease of use:models/: Contains the data structures and domain models, such asQuestion.client/: Houses the logic to handle communication with the RPC server.errors.py: Defines custom exception classes that the client may raise during
operation.Here is the layout of the project:my_rpc_client/
│
├── core/
│ ├── models/
│ │ └──── # Domain models such as the Question class
│ │
│ ├── client/
│ │ └──── # Handles the communication with the RPC server
│ │
│ └── errors.py
│    └─── # Custom exception classes for the client library
│
├── tests/
│ ├── test_models/
│ │ └──── # Unit tests for the domain models
│ │
│ └── test_client/
│   └──── # Unit tests for the RPC client functionality
│
├── examples/
│ └── # Example scripts on how to use the library
│
Package: turingAPI-final
There is a better API framework for IcodeYoudao now, and TuringAPI is out of support.IcodeAPI is hereTuringAPI, the API framework for IcodeYoudao.You can use TuringAPI to control your account on IcodeYoudao.fromturingAPI-finalimporticodeUseruser=icodeUser(input('Enter cookie: '))# loginprint(user.info)# user infoYou can useturingAPI.task,turingAPI.eventandturingAPI.eventPoolto concurrent.importturingAPI-finalasturingAPIuser=turingAPI.icodeUser(input('Enter cookie: '))ev=turingAPI.event(name='view')foriinrange(100):turingAPI.addTask(ev,user.getWorkDetail,'get{num}'.format(i),['66a116af4ade4abb97cc2bab3d57573f'],{})ev.run()Learn more in documents:TuringAPIGithub
Package: turing_calculator
Simple CalculatorWhat is this?A pretty straight forward calculator for Python that can do the following:Stores current value of number until it is resetAddition / SubtractionMultiplication / DivisionCalculate nth root of a numberInstallation:pip install turing_calculatorUsagefrom turing_calculator import CalculatorInitialise:calc = Calculator()Add 5 to current value:calc.add(5)Subtract 3:calc.subtract(3)Multiply by 25:calc.multiply(25)Divide by 2:calc.divide(2)Nth Root (In this case, square root):calc.root(2)Current Value:calc.valReset to zero:calc.reset()
Package: turing-chatroom-bus
ResponseSuccess{"_uid":<Theidoftherequest>,"success":<trueorfalse>,"error":<[Optional]errormessage>}Registerclient{"_uid":<uuid>,"path":<clientpath>}RPCRPC Request{"_uid":<uuid>,"path":<targetpath>,"payload":{"id":<RPCrequestid>,"method":<methodname>,"parameters":<parameters>}}RPC Response{"_uid":<uuid>,"path":<RPCrequestsourcepath>,"payload":{"id":<RPCrequestid>,"result":<RPCresult>,"error":<errormessage>}}
Package: turing_data_transformation_library
Data Transformation LibraryOverviewThis Python library is designed to assist data scientists in performing essential data transformations,
particularly for machine learning models. It provides a suite of functions that simplify common operations
in data processing and analysis.FeaturesThe library currently offers three primary functions:Transpose: A function to transpose matrices (2D tensors), switching their axes.Time Series Windowing: A tool for creating windows in time series data, essential for time series
analysis and modeling.Cross-Correlation: An implementation of the cross-correlation function, commonly used in convolutionalneural networks.TransposeFunction: transpose2d(input_matrix)Input: input_matrix - a list of lists of real numbers representing a 2D matrix.Output: Transposed matrix as a list of lists of real numbers.Implementation: Pure Python, using standard library.Time Series WindowingFunction: window1d(input_array, size, shift=1, stride=1)Inputs:input_array: List or 1D Numpy array of real numbers.size: Integer, size (length) of the window.shift: Integer, shift (step size) between windows.stride: Integer, stride (step size) within each window.Output: List of lists or 1D Numpy arrays of real numbers.Implementation: Python and Numpy.Cross-CorrelationFunction: convolution2d(input_matrix, kernel, stride=1)Inputs:input_matrix: 2D Numpy array of real numbers.kernel: 2D Numpy array of real numbers.stride: Integer, stride value.Output: 2D Numpy array of real numbers.Implementation: Python and Numpy.InstallationThe library is available on PyPI and can be installed using pip:pip install turing_data_transformation_libraryUsageAfter installation, the functions can be imported and used in Python scripts or Jupyter notebooks.Example usage:from turing_data_transformation_library.transpose import transpose2d
from turing_data_transformation_library.time_series_windowing import window1d
from turing_data_transformation_library.cross_correlation import convolution2d

# Example for transpose2d
matrix = [[1, 2], [3, 4]]
transpose2d(matrix)

# Example for window1d
input_array = [1, 2, 3, 4, 5]
size = 2
shift = 2
window1d(input_array, size, shift)

# Example for convolution2d
input_matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
kernel = [[1, 0], [0, -1]]
stride = 2
convolution2d(input_matrix, kernel, stride)
Package: turing-machine-executor
A Turing Machine Executor (EMT)A simple executor of(almost)every Turing machine.The NameThe ReasonsHow To Use EMTKnown Bugs and LimitationsThe NameEMTstands forEsecutore di Macchine di Turing, that is the Italian for"Turing Machine Executor".The ReasonsTo be completely honest I was just really bored and I needed a way to spend my time while learning new languages. I written this code in Python because I wanted to try using what I learnt about this language in the past months.How To Use EMTVisit theWiki pageto know how to use EMT.Known Bugs and LimitationsIn this section there's a list of known bugs and limitations of EMT. For future reference, if a bug is solved (or if a limitation is removed) it won't be deleted from this list, but it will be just marked as "deleted" (likethis).This executor can only start right before the input stringYou can't execute the same machine with more than one input tape without reinserting the machineThis executor is not muchuser friendly
Package: turing-machine-utils
Table of ContentsIntroductionFeaturesInstallationUsageConfigurationContributingLicenseIntroductionRun any Turing machine possible using this function and see if the turing machine, accepts or rejects the tape you input to it.Installationpipinstallturing-machine-utilsUsagefromturing_machine_utilsimportcreate_turing_machine# Define Turing Machine states, alphabet, and transition rulesstates=['q0','q1','accept','discard']transition_rules={('q0','0'):('q1','1','R'),('q0','1'):('q0','0','R'),('q1','0'):('accept','0','L'),('q1','1'):('discard','1','L'),}# Define the input tapetape=['0','1','0','1','0']# Run the Turing Machineresult,new_tape,state,symbol=create_turing_machine(tape,states,transition_rules)print("Result:",result)remember that the machine will start calculating the response from the first state. So the first element on the states list must be the beginning stateThe result will be:1 if the tape is accepted by the turing machine-1 if the state is discarded by the turing machine0 if an undefined transition is found by the turing machineThe new_tape is the tape with the changes to the original tapeThe state and symbol are normally None. They get values that say when the turing machine reached an undefined pointConfigurationNo specific configuration options are available at the moment.ContributingFeel free to contribute by reporting issues, suggesting improvements, or submitting pull requests.LicenseThis project is licensed under the MIT License - see theLICENSEfile for details.
Package: turingnetwork
**********FlashLight**********The Visualization Tool For Your NeuralNetwork---------------------------------------------.. image:: https://travis-ci.org/dlguys/flashlight.svg?branch=master:target: https://travis-ci.org/dlguys/flashlight.. image:: https://readthedocs.org/projects/flashlight/badge/?version=latest:target: http://flashlight.readthedocs.io/en/latest/?badge=latest:alt: Documentation Status.. image:: https://codecov.io/gh/dlguys/flashlight/branch/master/graph/badge.svg:target: https://codecov.io/gh/dlguys/flashlightFlashLight is built to make model interpretation easy. Rather than just being a visualization tool we wanted to make a playground for researchers and developers to debug the neural network and playe around with the graph. FlashLight currently supports only PyTorch model visualization but we are tyring to make it compatible with GLUON and TensorFlow eager.Usage=====FlashLight has very intuitive and non-exhaustive list of APIs available. The FlashLight object creation expects the user to pass the neural net instance>>> import FlashLight>>> net = NeuralNet()>>> viz = FlashLight(net)Calling the functional APIs saves the data to the FlashLight home folder which is by default ``$USERHOME/.flashlight``FlashLight installation creates the command line interface which also to call the FlashLight server. FlashLight server collects the data from FlashLight home folder and serves in the browser.Installation============FlashLight uses `sanic`_ as backend server. Sanic is dependant on python ``async`` and ``await`` and hence won't work with versions < python 3.5If your code base is python 3.5+,--------------------------------Everything works fine by installing FlashLight from pip. This will give you access to importable FlashLight package and command line interface that instantiates the Sanic server``pip install flashlight``If your code base is using python version < 3.5,-----------------------------------------------In this case, you are in bit trouble. We have created a separate FlashLight client for you to import in your script but FlashLight server still have to be with python3.5+, that means, you'll end up installing ``flashlight-client`` in your environment that uses older version of python and you need to create an environement with new version of python for running the FlashLight server. We really wanted to help you and hence we had created docker image also for you. Step for people who uses older version of python will be updated once we have a beta release... _sanic: https://github.com/channelcat/sanicFull Documentation is available in `readthedocs`_.. _readthedocs: http://flashlight.readthedocs.io/
Package: turingproject
Calculator PackageThe Calculator package provides a Calculator class that allows you to perform basic arithmetic operations and manipulate a memory value.InstallationTo install the Calculator package, you can use pip:pip install calculator-packageUsageFirst, import theCalculatorclass from the package:fromcalculator_packageimportCalculatorCreate a Calculator instance:calc=Calculator()Perform calculations using the available methods:calc.add(5)calc.subtract(2)calc.multiply(3)calc.divide(2)calc.root(2)Access the current memory value:print("Memory:",calc.memory)Reset the memory:calc.reset_memory()print("Memory after reset:",calc.memory)Refer to the docstrings in the source code for detailed information on each method.ContributingContributions are welcome! If you find any issues or have suggestions for improvement, please open an issue or submit a pull request on theGitHub repository.LicenseThis package is licensed under theMIT License.
Package: turingquant
Turing Quantturingquanté uma biblioteca para coleta, análise e backtesting de ativos e estratégias financeiras. O projeto está em desenvolvimento ativo pelos membros de Finanças Quantitativas doGrupo Turing.pip install turingquantinstala a última versão estável.UtilizaçãoA biblioteca conta com 3 módulos:metrics,benchmark, esupport.supportpossui funções para obter dados fundamentalistas de empresas.metricspossui funções para obter informações e indicadores sobre uma série de retornos.benchmarkpossui funções para calcular o retorno de um ativo em um dado intervalo de tempo.optimizerspossui classes para otimizações de carteiras de investimento.A API de onde obtemos os dados fundamentalistas é a Alpha Vantage e você pode obter achave de uso gratuitamente. Essa chave será necessária sempre que você utilizar as funçõesdailyeintraday.No código você pode verificar o que cada função retorna e a descrição de cada parâmetro que as funções recebem.ContribuidoresGabriel MossatoGuilherme Colasante SgarbieroGuilherme Corazza MarquesGuilherme FernandesJulia PocciottiLucas LemeNoel Viscome Eliezer
Package: turing-sdk
IntroductionThe Turing SDK is a Python tool for interacting with the Turing API, and complements the existing Turing UI available
for managing router creation, deployment, versioning, etc.It not only allows you to build your routers in an incremental and configurable manner, it
also gives you the opportunity to write imperative scripts to automate various router modification and deployment
processes, hence simplifying your workflow when interacting with Turing API.What is the Turing SDK?The Turing SDK is entirely written in Python and acts as a wrapper, around the classes automatically generated (byOpenAPI Generator) from the OpenAPI specs written for the Turing
API. These generated classes in turn act as an intermediary between raw JSON objects that are passed in HTTP
requests/responses made to/received from the Turing API.If you're someone who has used Turing/the Turing UI and would like more control and power over router
management, the Turing SDK fits perfectly for your needs.Note that using the Turing SDK assumes that you have basic knowledge of what Turing does and how Turing routers
operate. If you are unsure of these, refer to the Turing UIdocsand
familiarise yourself with them first. A list of useful and important concepts used in Turing can also be foundhere.Note that some functionalities available with the UI are not available with the Turing SDK, e.g. creating new projects.SamplesSamples of how the Turing SDK can be used to manage routers can be foundhere.
Package: turing-transforms2
OverviewThis is a simple library for utility functions for data processing.
Currently implemented functions are:cross-correlationtransposewindow.InstallationPrerequisitesPython 3.10 or newer.Just runpip install turing_transforms2Usagefromturing_transforms.windowimportwindow1dwindows=window1d(list(range(5)),size=2)Future improvementsconvolution support for padding and channel dimension.transpose support for multiple dimensions.Package is accessabe atPypi.
Package: turjuman
Turjuman, a neural toolkit for translating from 20 languages into Modern
Standard Arabic (MSA) that described in our OSACT5 2022 paper “TURJUMAN:
A Public Toolkit for Neural Arabic Machine Translation”.TURJUMAN exploits the recently-introduced our text-to-text TransformerAraT5 model, endowing it with a powerful ability to decode into Arabic. The
toolkit offers the possibility of employing a number of diverse decoding
methods, making it suited for acquiring paraphrases for the MSA
translations as an added value. To train TURJUMAN, we sample from
publicly available parallel data employing a simple semantic similarity
method to ensure data quality.GitHub link:https://github.com/UBC-NLP/turjumanOnline demo link:https://demos.dlnlp.ai/turjumanGetting StartedThefull documentationcontains instructions for getting started, translation using diffrent
methods, intergrate Turjuman with your code, and provides more examples.Licenseturjuman(-py) is Apache-2.0 licensed. The license applies to the
pre-trained models as well.CitationIf you use TURJUMAN toolkit or the pre-trained models for your
scientific publication, or if you find the resources in this repository
useful, please cite our paper as follows:@inproceedings{nagoudi-osact5-2022-turjuman,
  title={TURJUMAN: A Public Toolkit for Neural Arabic Machine Translation},
  author={Nagoudi, El Moatez Billah and Elmadany, AbdelRahim and Abdul-Mageed, Muhammad},
  booktitle = "Proceedings of the 5th Workshop on Open-Source Arabic Corpora and Processing Tools (OSACT5)",
  month = "June",
  year = "2022",
  address = "Marseille, France",
  publisher = "European Language Resource Association",
}7. AcknowledgmentsWe gratefully acknowledge support from the Natural Sciences and Engineering Research Council of Canada (NSERC; RGPIN-2018-04267), the Social Sciences and Humanities Research Council of Canada (SSHRC; 435-2018-0576; 895-2020-1004; 895-2021-1008),ComputeCanada (CC)andUBC
ARC-Sockeyeand Advanced Micro Devices, Inc. (AMD). Any opinions, conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of NSERC, SSHRC, CFI, CC, AMD, or UBC ARC-Sockeye.