repository (nest_backend.database.tables.Authorization attributo)

repository_id (nest_backend.database.tables.Condition attributo)

evaluation_mode (nest_backend.database.tables.Repository attributo)

authorizations (nest_backend.database.tables.Repository attributo)

coordinates (nest_backend.database.tables.ConditionType attributo)

Inserire activity log di Giorgio Minoccari relativo allo Sprint 3.

La seguente documentazione è stata fornita dal cliente durante questo sprint:

Il **goal** del terzo Sprint è stato far funzionare il crawler, gli alert e completare tutte i task rimanenti.

 del terzo Sprint è stato far funzionare il crawler, gli alert e completare tutte i task rimanenti.

Sono state definite le nuove **User Stories** da inserire nel progetto sulla base delle nuove richieste
pervenute dal cliente:

 da inserire nel progetto sulla base delle nuove richieste

La richiesta relativa alle *ricerche basate sulla geolocalizzazione*, come già comunicato al cliente, non è stata
completata interamente per motivi tecnici legati a limitazioni sulle features delle **API 1.1 di Twitter** che non
permettono di eseguire query su campi di posizione geografica.

, come già comunicato al cliente, non è stata
completata interamente per motivi tecnici legati a limitazioni sulle features delle 

 che non

Le nuove User Stories sono state valutate tramite Scrum Poker, durante il quale ogni membro ha espresso
la sua valutazione.

Tutte le nuove richieste sono state accettate dal Product Owner e sono pronte ad essere inserite nello sprint di
sviluppo in partenza.

Il team ha definito lo stato di Ready di una User Story in base ai seguenti criteri:

Il Product Owner ha la visione necessaria per definirne la priorità

La User Story è indipendente o dipendente da altre a priorità maggiore

La definizione di Done è stata concordata da tutto il team con il Product Owner, ed è stata così definita:

La statistica dello sprint 3 non è ancora stata generata dal prof. Marcello Missiroli.

https://drive.google.com/file/d/15o70Ffe51CNj8LTKHC9dGiqRVnbv9UpZ/view

Aggiornamento documentazione, aggiunti ulteriori test seguendo i suggerimenti di SQ

ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON 3.8.10 DOCUMENTATION

email.message.Message: Representing an email message using the compat32 API

What is the most efficient way to concatenate many strings together?

Why does a_tuple[i] += [‘item’] raise an exception when the addition works?

What does the slash(/) in the parameter list of a function mean?

PEP 3118: New memoryview implementation and buffer protocol documentation

PEP 476: Enabling certificate verification by default for stdlib http clients

PEP 471 - os.scandir() function – a better and faster directory iterator

Why must ‘self’ be used explicitly in method definitions and calls?

argparse — Parser for command-line options, arguments and sub-commands

functools — Higher-order functions and operations on callable objects

multiprocessing.shared_memory —  Provides shared memory for direct access across processes

sysconfig — Provide access to Python’s configuration information

:class:`tweepy.asynchronous.asyncstream` --- asynchronous stream reference

TextClause.columns() will match columns positionally, not by name, when passed positionally

JSON Columns will not insert JSON NULL if no value is supplied and no default is established

Session.get_bind() handles a wider variety of inheritance scenarios

session.expunge() will fully detach an object that’s been deleted

ColumnProperty constructs work a lot better with aliases, order_by

Session.get_bind() will receive the Mapper in all relevant Query cases

query.update() now resolves string names into mapped attribute names

Python-side defaults invoked for each row individually when using a multivalued insert

Warnings emitted when comparing objects with None values to relationships

A “negated contains or equals” relationship comparison will use the current value of attributes, not the database value

API Change for new Bundle feature when custom row loaders are used

Many-to-one backref checks for collection duplicates during remove operation

Support for SQL Comments on Table, Column, includes DDL, reflection

INSERT FROM SELECT now includes Python and SQL-expression defaults

A UNION or similar of SELECTs with LIMIT/OFFSET/ORDER BY now parenthesizes the embedded selects

attributes.get_history() will query from the DB by default if value not present

Schema identifiers now carry along their own quoting information

Subquery Eager Loading will apply DISTINCT to the innermost SELECT for some queries

Large parameter and row values are now truncated in logging and exception displays

The typing system now handles the task of rendering “literal bind” values

TypeDecorator now works with Enum, Boolean, “schema” types automatically

Support for RANGE and ROWS specification within window functions

Stringify of Query will consult the Session for the correct dialect

New Function features, “WITHIN GROUP”, array_agg and set aggregate functions

Event listeners can not be added or removed from within that event’s runner

PyODBC driver name is required with hostname-based SQL Server connections

SQLite/Oracle have distinct methods for temporary table/view name reporting

The .autoincrement directive is no longer implicitly enabled for a composite primary key column

Subqueries no longer applied to uselist=False joined eager loads

New options allowing explicit persistence of NULL over a default

The match() operator now returns an agnostic MatchType compatible with MySQL’s floating point return value

MySQL SET Type Overhauled to support empty sets, unicode, blank value handling

Specific checks added for passing mapped classes, instances as SQL literals

Constraints referring to unattached Columns can auto-attach to the Table when their referred columns are attached

AssociationProxy stores class-specific state on a per-class basis

Joined eager loading where the same entity is present multiple times in one row

Changes regarding “unhashable” types, impacts deduping of ORM rows

ResultSet column matching enhancements; positional column setup for textual SQL

Correct SQL Types are Established from Indexed Access of ARRAY, JSON, HSTORE

The JSON cast() operation now requires .astext is called explicitly

String / varlength types no longer represent “max” explicitly on reflection

JSON “null” is inserted as expected with ORM operations, omitted when not present

Same-named backrefs will not raise an error when applied to concrete inheritance subclasses

“Friendly” stringification of Core SQL constructs without a dialect

Hybrid properties and methods now propagate the docstring as well as .info

Improvements to the Query.correlate method with polymorphic entities

Erroneous “new instance X conflicts with persistent instance Y” flush errors fixed

Improved Session state when a SAVEPOINT is cancelled by the database

Fix involving many-to-one object moves with user-initiated foreign key manipulations

Non-native boolean integer values coerced to zero/one/None in all cases

Use flag_dirty() to mark an object as “dirty” without any attribute changing

AssociationProxy any(), has(), contains() work with chained association proxies

Engines now invalidate connections, run error handlers for BaseException

passive_deletes=’all’ will leave FK unchanged for object removed from collection

Fixed issue involving single-table inheritance with select_from()

A @validates method receives all values on bulk-collection set before comparison

The IN / NOT IN operator’s empty collection behavior is now configurable; default expression simplified

Hybrid attributes support reuse among subclasses, redefinition of @getter

Pessimistic disconnection detection added to the connection pool

The after_rollback() Session event now emits before the expiration of objects

New “selectin” eager loading, loads all collections at once using IN

“selectin” polymorphic loading, loads subclasses using separate IN queries

Late-expanded IN parameter sets allow IN expressions with cached statements

Support for fields specification in INTERVAL, including full reflection

TypeEngine methods bind_expression, column_expression work with Variant, type-specific types

The typing behavior of custom operators has been made consistent

Parameter helper for multi-valued INSERT with contextual default generator

Horizontal Sharding extension supports bulk update and delete methods

Added basic reflection support for PostgreSQL partitioned tables

National char datatypes de-emphasized for generic unicode, re-enabled with option

FOR UPDATE clause is rendered within the joined eager load subquery as well as outside

AssociationProxy now provides standard column operators for a column-oriented target

Many-to-one replacement won’t raise for “raiseload” or detached for “old” object

New parameters to affect IDENTITY start and increment, use of Sequence deprecated

Query.join() handles ambiguity in deciding the “left” side more explicitly

cx_Oracle connect arguments modernized, deprecated parameters removed

Deprecation warnings are emitted for all deprecated elements; new deprecations added

Relationship to AliasedClass replaces the need for non primary mappers

Improved column labeling for simple column expressions using CAST or similar

Accessing an uninitialized collection attribute on a transient object no longer mutates __dict__

A SELECT statement is no longer implicitly considered to be a FROM clause

Transparent SQL Compilation Caching added to All DQL, DML Statements in Core, ORM

All IN expressions render parameters for each value in the list on the fly (e.g. expanding parameters)

Repaired internal importing conventions such that code linters may work correctly

The “New instance conflicts with existing identity” error is now a warning

RowProxy is no longer a “proxy”; is now called Row and behaves like an enhanced named tuple

Connection-level transactions can now be inactive based on subtransaction

Built-in FROM linting will warn for any potential cartesian products in a SELECT statement

SELECT objects and derived FROM clauses allow for duplicate columns and column labels

New “post compile” bound parameters used for LIMIT/OFFSET in Oracle, SQL Server

Removed “join rewriting” logic from SQLite dialect; updated imports

Persistence-related cascade operations disallowed with viewonly=True

Python Dataclasses, attrs Supported w/ Declarative, Imperative Mappings

Stricter behavior when querying inheritance mappings using custom queries

ORM Query is internally unified with select, update, delete; 2.0 style execution available

ORM Batch inserts with psycopg2 now batch statements with RETURNING in most cases

Enum and Boolean datatypes no longer default to “create constraint”

psycopg2 dialect features “execute_values” with RETURNING for INSERT statements by default

Python 3.6 is the minimum Python 3 version; Python 2.7 still supported

psycopg2 dialect no longer has limitations regarding bound parameter names

Many Core and ORM statement objects now perform much of their construction and validation in the compile phase

No more generation of an implicit KEY for composite primary key w/ AUTO_INCREMENT

ORM Bulk Update and Delete use RETURNING for “fetch” strategy when available

select().join() and outerjoin() add JOIN criteria to the current query, rather than creating a subquery

Routing Explicit Joins/Statements into Eagerly Loaded Collections

Fine grained control over cx_Oracle data binding performance with setinputsizes

Disabling or using an alternate dictionary to cache some (or all) statements

Using Lambdas to add significant speed gains to statement production

QueuePool limit of size <x> overflow <y> reached, connection timed out, timeout <z>

This Session’s transaction has been rolled back due to a previous exception during flush

Expected FROM clause, got Select.  To create a FROM clause, use the .subquery() method

This connection is on an inactive transaction.  Please rollback() fully before proceeding

The <some function> in SQLAlchemy 2.0 will no longer <something>

For relationship <relationship>, delete-orphan cascade is normally configured only on the “one” side of a one-to-many relationship, and not on the “many” side of a many-to-one or many-to-many relationship.

Instance <instance> is already associated with an instance of <instance> via its <attribute> attribute, and is only allowed a single parent.

Parent instance <x> is not bound to a Session; (lazy load/deferred load/refresh/etc.) operation cannot proceed

select() construct created in “legacy” mode; keyword arguments, etc.

A bind was located via legacy bound metadata, but since future=True is set on this Session, this bind is ignored.

A value is required for bind parameter <x> (in parameter group <y>)

Compiler StrSQLCompiler can’t render element of type <element type>

relationship X will copy column Q to column P, which conflicts with relationship(s): ‘Y’

I’m getting a warning or error about “Implicitly combining column X under attribute Y”

Using DBAPI Autocommit Allows for a Readonly Version of Transparent Reconnect

Why does post_update emit UPDATE in addition to the first UPDATE?

My Query does not return the same number of objects as query.count() tells me - why?

I’m re-loading data with my Session but it isn’t seeing changes that I committed elsewhere

“This Session’s transaction has been rolled back due to a previous exception during flush.” (or similar)

I’m using op() to generate a custom operator and my parenthesis are not coming out correctly

Why are percent signs being doubled up when stringifying SQL statements?

How do I render SQL expressions as strings, possibly with bound parameters inlined?

Why is ORDER BY required with LIMIT (especially with subqueryload())?

Floating Point String-Conversion Precision Configurable for Native Floating Point Types

Select/Query LIMIT / OFFSET may be specified as an arbitrary SQL expression

Improvements to declarative mixins, @declared_attr and related features

The use_alter flag on ForeignKeyConstraint is (usually) no longer needed

Many JOIN and LEFT OUTER JOIN expressions will no longer be wrapped in (SELECT * FROM ..) AS ANON_1

Identity Columns (GENERATED { ALWAYS | BY DEFAULT } AS IDENTITY)

Dealing with Key Mutations and back-populating for Dictionary collections

The consideration of a “pending” object as an “orphan” has been made more aggressive

create_all() and drop_all() will now honor an empty list as such

Label constructs can now render as their name alone in an ORDER BY

Columns can reliably get their type from a column referred to via ForeignKey

select() no longer accepts varied constructor arguments, columns are passed positionally

Library-level (but not driver level) “Autocommit” removed from both Core and ORM

“Implicit” and “Connectionless” execution, “bound metadata” removed

ORM Query  - Joining / loading on relationships uses attributes, not strings

Using DISTINCT with additional columns, but only select the entity

Selecting from the query itself as a subquery, e.g. “from_self()”

_query.Query.select_from() no longer applies the clause to corresponding entities

Improved rendering of Boolean constants, NULL constants, conjunctions

Composite attributes are now returned as their object form when queried on a per-attribute basis

viewonly=True on relationship() prevents history from taking effect

A bindparam() construct with no type gets upgraded via copy when a type is available

The “password” portion of a create_engine() no longer considers the + sign as an encoded space

PostgreSQL CREATE TYPE <x> AS ENUM now applies quoting to values

Right inner join nesting now the default for joinedload with innerjoin=True

Priority of attribute changes on relationship-bound attributes vs. FK-bound may appear to change

Changes to attribute events and other operations regarding attributes that have no pre-existing value

Change to single-table-inheritance criteria when using from_self(), count()

single-table-inheritance criteria added to all ON clauses unconditionally

Joined/Subquery eager loading explicitly disallowed with yield_per

“Commands out of sync; you can’t run this command now” / “This result object does not return rows. It has been closed automatically”

Rendering ON UPDATE CURRENT TIMESTAMP for MySQL / MariaDB’s explicit_defaults_for_timestamp

I’m getting errors related to “numpy.int64”, “numpy.bool_”, etc.

Selecting ORM Objects Inline with UPDATE.. RETURNING or INSERT..RETURNING

Creating an Explicit Base Non-Dynamically (for use with mypy, similar)

Table values, Table and Column valued functions, Row and Tuple objects

Notes on Delete - Deleting Objects Referenced from Collections and Scalar Relationships

Joining a Session into an External Transaction (such as for test suites)

When do I construct a Session, when do I commit it, and when do I close it?

Partitioning Strategies (e.g. multiple database backends per Session)

Using More Specific Text with table(), _expression.literal_column(), and _expression.column()

Marking Implicitly Generated Values, timestamps, and Triggered Columns

Column Valued Functions - Table Valued Function as a Scalar Column